dot11_base.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_H) && defined(TINS_HAVE_DOT11)
#define TINS_DOT11_DOT11_H

#include <tins/pdu.h>
#include <tins/pdu_option.h>
#include <tins/small_uint.h>
#include <tins/hw_address.h>
#include <tins/endianness.h>
#include <tins/cxxstd.h>
#include <tins/macros.h>

namespace Tins {
namespace Memory {
class InputMemoryStream;
class OutputMemoryStream;
} // Memory

class RSNInformation;

class TINS_API Dot11 : public PDU {
public:
    typedef HWAddress<6> address_type;

    typedef PDUOption<uint8_t, Dot11> option;

    typedef std::vector<option> options_type;

    static const PDU::PDUType pdu_flag = PDU::DOT11;

    static const address_type BROADCAST;

    static const endian_type endianness = LE;

    enum Types {
        MANAGEMENT = 0,
        CONTROL = 1,
        DATA = 2
    };

    enum OptionTypes {
        SSID,
        SUPPORTED_RATES,
        FH_SET,
        DS_SET,
        CF_SET,
        TIM,
        IBSS_SET,
        COUNTRY,
        HOPPING_PATTERN_PARAMS,
        HOPPING_PATTERN_TABLE,
        REQUEST_INFORMATION,
        BSS_LOAD,
        EDCA,
        TSPEC,
        TCLAS,
        SCHEDULE,
        CHALLENGE_TEXT,
        POWER_CONSTRAINT = 32,
        POWER_CAPABILITY,
        TPC_REQUEST,
        TPC_REPORT,
        SUPPORTED_CHANNELS,
        CHANNEL_SWITCH,
        MEASUREMENT_REQUEST,
        MEASUREMENT_REPORT,
        QUIET,
        IBSS_DFS,
        ERP_INFORMATION,
        TS_DELAY,
        TCLAS_PROCESSING,
        QOS_CAPABILITY = 46,
        RSN = 48,
        EXT_SUPPORTED_RATES = 50,
        VENDOR_SPECIFIC = 221
    };

    enum ManagementSubtypes {
        ASSOC_REQ = 0,
        ASSOC_RESP = 1,
        REASSOC_REQ = 2,
        REASSOC_RESP = 3,
        PROBE_REQ = 4,
        PROBE_RESP = 5,
        BEACON = 8,
        ATIM = 9,
        DISASSOC = 10,
        AUTH = 11,
        DEAUTH = 12
    };

    enum ControlSubtypes {
        BLOCK_ACK_REQ = 8,
        BLOCK_ACK = 9,
        PS = 10,
        RTS = 11,
        CTS = 12,
        ACK = 13,
        CF_END = 14,
        CF_END_ACK = 15
    };

    enum DataSubtypes {
        DATA_DATA = 0,
        DATA_CF_ACK = 1,
        DATA_CF_POLL = 2,
        DATA_CF_ACK_POLL = 3,
        DATA_NULL = 4,
        CF_ACK = 5,
        CF_POLL = 6,
        CF_ACK_POLL = 7,
        QOS_DATA_DATA = 8,
        QOS_DATA_CF_ACK = 9,
        QOS_DATA_CF_POLL = 10,
        QOS_DATA_CF_ACK_POLL = 11,
        QOS_DATA_NULL = 12
    };
    
    Dot11(const address_type& dst_hw_addr = address_type());

    Dot11(const uint8_t* buffer, uint32_t total_sz);

    small_uint<2> protocol() const {
        return header_.control.protocol;
    }

    small_uint<2> type() const {
        return header_.control.type;
    }

    small_uint<4> subtype() const {
        return header_.control.subtype;
    }

    small_uint<1> to_ds() const {
        return header_.control.to_ds;
    }

    small_uint<1> from_ds() const {
        return header_.control.from_ds;
    }

    small_uint<1> more_frag() const {
        return header_.control.more_frag;
    }

    small_uint<1> retry() const {
        return header_.control.retry;
    }

    small_uint<1> power_mgmt() const {
        return header_.control.power_mgmt;
    }

    small_uint<1> more_data() const {
        return header_.control.more_data;
    }

    small_uint<1> wep() const {
        return header_.control.wep;
    }

    small_uint<1> order() const {
        return header_.control.order;
    }

    uint16_t duration_id() const {
        return Endian::le_to_host(header_.duration_id);
    }

    address_type addr1() const {
        return header_.addr1;
    }

    // Setters

    void protocol(small_uint<2> new_proto);

    void type(small_uint<2> new_type);

    void subtype(small_uint<4> new_subtype);

    void to_ds(small_uint<1> new_value);

    void from_ds(small_uint<1> new_value);

    void more_frag(small_uint<1> new_value);

    void retry(small_uint<1> new_value);

    void power_mgmt(small_uint<1> new_value);

    void more_data(small_uint<1> new_value);

    void wep(small_uint<1> new_value);

    void order(small_uint<1> new_value);

    void duration_id(uint16_t new_duration_id);

    void addr1(const address_type& new_addr1);

    /* Virtual methods */
    uint32_t header_size() const;
    
    #ifndef _WIN32

    void send(PacketSender& sender, const NetworkInterface& iface);
    #endif // _WIN32
    
    void add_option(const option& opt);
    
    #if TINS_IS_CXX11

        void add_option(option &&opt) {
            internal_add_option(opt);
            options_.push_back(std::move(opt));
        }
    #endif

    bool remove_option(OptionTypes type);

    const option* search_option(OptionTypes type) const;

    PDUType pdu_type() const {
        return pdu_flag;
    }
    
    Dot11* clone() const {
        return new Dot11(*this);
    }

    bool matches_flag(PDUType flag) const {
       return flag == pdu_flag;
    }
    
    const options_type& options() const {
        return options_;
    }

    static Dot11* from_bytes(const uint8_t* buffer, uint32_t total_sz);
protected:
    virtual void write_ext_header(Memory::OutputMemoryStream& stream);
    virtual void write_fixed_parameters(Memory::OutputMemoryStream& stream);
    void parse_tagged_parameters(Memory::InputMemoryStream& stream);
    void add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t* val);
protected:
    TINS_BEGIN_PACK
    struct dot11_header {
        TINS_BEGIN_PACK
        struct {
        #if TINS_IS_LITTLE_ENDIAN
            uint16_t protocol:2,
                    type:2,
                    subtype:4,
                    to_ds:1,
                    from_ds:1,
                    more_frag:1,
                    retry:1,
                    power_mgmt:1,
                    more_data:1,
                    wep:1,
                    order:1;
        #elif TINS_IS_BIG_ENDIAN
            uint16_t subtype:4,
                    type:2,
                    protocol:2,
                    order:1,
                    wep:1,
                    more_data:1,
                    power_mgmt:1,
                    retry:1,
                    more_frag:1,
                    from_ds:1,
                    to_ds:1;
        #endif
        } TINS_END_PACK control;
        uint16_t duration_id;
        uint8_t addr1[address_type::address_size];

    } TINS_END_PACK;
private:
    Dot11(const dot11_header* header_ptr);
    
    void internal_add_option(const option& opt);
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    options_type::const_iterator search_option_iterator(OptionTypes type) const;
    options_type::iterator search_option_iterator(OptionTypes type);


    dot11_header header_;
    uint32_t options_size_;
    options_type options_;
};

} // Tins

#endif // TINS_DOT11_DOT11_H