dot11_data.h

/*
 * Copyright (c) 2017, Matias Fontanini
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <tins/config.h>

#if !defined(TINS_DOT11_DOT11_DATA_H) && defined(TINS_HAVE_DOT11)
#define TINS_DOT11_DOT11_DATA_H

#include <tins/dot11/dot11_base.h>
#include <tins/macros.h>

namespace Tins {

class TINS_API Dot11Data : public Dot11 {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_DATA;
    
    Dot11Data(const address_type& dst_hw_addr = address_type(), 
              const address_type& src_hw_addr = address_type());
                
    Dot11Data(const uint8_t* buffer, uint32_t total_sz);
    
    address_type addr2() const {
        return ext_header_.addr2;
    }

    address_type addr3() const {
        return ext_header_.addr3;
    }

    small_uint<4> frag_num() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return ext_header_.frag_seq & 0xf; 
        #else
        return (ext_header_.frag_seq >> 8) & 0xf; 
        #endif
    }

    small_uint<12> seq_num() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return (ext_header_.frag_seq >> 4) & 0xfff; 
        #else
        return (Endian::le_to_host<uint16_t>(ext_header_.frag_seq) >> 4) & 0xfff; 
        #endif
    }

    address_type addr4() const {
        return addr4_;
    }

    void addr2(const address_type& new_addr2);

    void addr3(const address_type& new_addr3);

    void frag_num(small_uint<4> new_frag_num);

    void seq_num(small_uint<12> new_seq_num);

    void addr4(const address_type& new_addr4);

    address_type src_addr() const {
        if (!from_ds() && !to_ds()) {
            return addr2();
        }
        if (!from_ds() && to_ds()) {
            return addr2();
        }
        return addr3();
    }

    address_type dst_addr() const {
        if (!from_ds() && !to_ds()) {
            return addr1();
        }
        if (!from_ds() && to_ds()) {
            return addr3();
        }
        return addr1();
    }

    address_type bssid_addr() const {
        if (!from_ds() && !to_ds()) {
            return addr3();
        }
        if (!from_ds() && to_ds()) {
            return addr1();
        }
        return addr2();
    }

    uint32_t header_size() const;

    PDUType pdu_type() const {
        return pdu_flag;
    }

    bool matches_flag(PDUType flag) const {
       return flag == pdu_flag || Dot11::matches_flag(flag);
    }

    Dot11Data* clone() const {
        return new Dot11Data(*this);
    }
protected:
    TINS_BEGIN_PACK
    struct dot11_extended_header {
        uint8_t addr2[address_type::address_size];
        uint8_t addr3[address_type::address_size];
        uint16_t frag_seq;
    } TINS_END_PACK;
    
    struct no_inner_pdu { };
    Dot11Data(const uint8_t* buffer, uint32_t total_sz, no_inner_pdu);

    uint32_t init(const uint8_t* buffer, uint32_t total_sz);
    void write_ext_header(Memory::OutputMemoryStream& stream);
private:
    dot11_extended_header ext_header_;
    address_type addr4_;
};

class TINS_API Dot11QoSData : public Dot11Data {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_QOS_DATA;

    Dot11QoSData(const address_type& dst_hw_addr = address_type(), 
                 const address_type& src_hw_addr = address_type());

    Dot11QoSData(const uint8_t* buffer, uint32_t total_sz);
    
    uint16_t qos_control() const {
        return Endian::le_to_host(qos_control_);
    }

    void qos_control(uint16_t new_qos_control);

    uint32_t header_size() const;

    Dot11QoSData* clone() const {
        return new Dot11QoSData(*this);
    }

    PDUType pdu_type() const {
        return pdu_flag;
    }

    bool matches_flag(PDUType flag) const {
       return flag == pdu_flag || Dot11Data::matches_flag(flag);
    }
private:
    void write_fixed_parameters(Memory::OutputMemoryStream& stream);

    uint16_t qos_control_;
};
}

#endif // TINS_DOT11_DOT11_DATA_H