dot11_mgmt.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_MGMT_H) && defined(TINS_HAVE_DOT11)

#define TINS_DOT11_DOT11_MGMT_H

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

namespace Tins {
class TINS_API Dot11ManagementFrame : public Dot11 {
public:
    typedef std::vector<float> rates_type;
    
    typedef std::vector<std::pair<uint8_t, uint8_t> > channels_type;

    typedef std::vector<std::pair<uint8_t, uint8_t> > channel_map_type;

    typedef std::vector<uint8_t> request_info_type;

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

    enum ReasonCodes {
        UNSPECIFIED = 1,
        PREV_AUTH_NOT_VALID = 2,
        STA_LEAVING_IBSS_ESS = 3,
        INACTIVITY = 4,
        CANT_HANDLE_STA = 5,
        CLASS2_FROM_NO_AUTH = 6,
        CLASS3_FROM_NO_AUTH = 7,
        STA_LEAVING_BSS = 8,
        STA_NOT_AUTH_WITH_STA = 9,
        POW_CAP_NOT_VALID = 10,
        SUPPORTED_CHANN_NOT_VALID = 11,
        INVALID_CONTENT = 13,
        MIC_FAIL = 14,
        HANDSHAKE_TIMEOUT = 15,
        GROUP_KEY_TIMEOUT = 16,
        WRONG_HANDSHAKE = 17,
        INVALID_GROUP_CIPHER = 18,
        INVALID_PAIRWISE_CIPHER = 19,
        INVALID_AKMP = 20,
        UNSOPPORTED_RSN_VERSION = 21,
        INVALID_RSN_CAPABILITIES = 22,
        AUTH_FAILED = 23,
        CIPHER_SUITE_REJECTED = 24,
        UNSPECIFIED_QOS_REASON = 32,
        NOT_ENOUGH_BANDWITH = 33,
        POOR_CHANNEL = 34,
        STA_OUT_OF_LIMITS = 35,
        REQUESTED_BY_STA_LEAVING = 36,
        REQUESTED_BY_STA_REJECT_MECHANISM = 37,
        REQUESTED_BY_STA_REJECT_SETUP = 38,
        REQUESTED_BY_STA_TIMEOUT = 39,
        PEER_STA_NOT_SUPPORT_CIPHER = 45
    };

    enum MapMask {
        BSS                 = 0x1,
        OFDM_PREAMBLE       = 0x2,
        UNIDENTIFIED_SIGNAL = 0x4,
        RADAR               = 0x8,
        UNMEASURED          = 0x10,
        RESERVED            = 0xE0
    };
    
    TINS_BEGIN_PACK
    class capability_information {
    private:
        #if TINS_IS_LITTLE_ENDIAN
            uint16_t ess_:1,
                     ibss_:1,
                     cf_poll_:1,
                     cf_poll_req_:1,
                     privacy_:1,
                     short_preamble_:1,
                     pbcc_:1,
                     channel_agility_:1,
                     spectrum_mgmt_:1,
                     qos_:1,
                     sst_:1,
                     apsd_:1,
                     radio_measurement_:1,
                     dsss_ofdm_:1,
                     delayed_block_ack_:1,
                     immediate_block_ack_:1;
        #elif TINS_IS_BIG_ENDIAN
            uint16_t channel_agility_:1,
                     pbcc_:1,
                     short_preamble_:1,
                     privacy_:1,
                     cf_poll_req_:1,
                     cf_poll_:1,
                     ibss_:1,
                     ess_:1,
                     immediate_block_ack_:1,
                     delayed_block_ack_:1,
                     dsss_ofdm_:1,
                     radio_measurement_:1,
                     apsd_:1,
                     sst_:1,
                     qos_:1,
                     spectrum_mgmt_:1;
        #endif
    public:
        bool ess() const {
            return ess_;
        }

        bool ibss() const {
            return ibss_;
        }

        bool cf_poll() const {
            return cf_poll_;
        }

        bool cf_poll_req() const {
            return cf_poll_req_;
        }

        bool privacy() const {
            return privacy_;
        }

        bool short_preamble() const {
            return short_preamble_;
        }

        bool pbcc() const {
            return pbcc_;
        }

        bool channel_agility() const {
            return channel_agility_;
        }

        bool spectrum_mgmt() const {
            return spectrum_mgmt_;
        }

        bool qos() const {
            return qos_;
        }

        bool sst() const {
            return sst_;
        }

        bool apsd() const {
            return apsd_;
        }

        bool radio_measurement() const {
            return radio_measurement_;
        }

        bool dsss_ofdm() const {
            return dsss_ofdm_;
        }

        bool delayed_block_ack() const {
            return delayed_block_ack_;
        }

        bool immediate_block_ack() const {
            return immediate_block_ack_;
        }

        void ess(bool new_value) {
            ess_ = new_value;
        }

        void ibss(bool new_value) {
            ibss_ = new_value;
        }

        void cf_poll(bool new_value) {
            cf_poll_ = new_value;
        }

        void cf_poll_req(bool new_value) {
            cf_poll_req_ = new_value;
        }

        void privacy(bool new_value) {
            privacy_ = new_value;
        }

        void short_preamble(bool new_value) {
            short_preamble_ = new_value;
        }

        void pbcc(bool new_value) {
            pbcc_ = new_value;
        }

        void channel_agility(bool new_value) {
            channel_agility_ = new_value;
        }

        void spectrum_mgmt(bool new_value) {
            spectrum_mgmt_ = new_value;
        }

        void qos(bool new_value) {
            qos_ = new_value;
        }

        void sst(bool new_value) {
            sst_ = new_value;
        }

        void apsd(bool new_value) {
            apsd_ = new_value;
        }

        void radio_measurement(bool new_value) {
            radio_measurement_ = new_value;
        }

        void dsss_ofdm(bool new_value) {
            dsss_ofdm_ = new_value;
        }

        void delayed_block_ack(bool new_value) {
            delayed_block_ack_ = new_value;
        }

        void immediate_block_ack(bool new_value) {
            immediate_block_ack_ = new_value;
        }
    } TINS_END_PACK;
    
    struct fh_params_set {
        uint16_t dwell_time;
        uint8_t hop_set, hop_pattern, hop_index;
        
        fh_params_set()
        : dwell_time(0), hop_set(0), hop_pattern(0), hop_index(0) {}
        
        fh_params_set(uint16_t dwell_time, 
                      uint8_t hop_set, 
                      uint8_t hop_pattern,
                      uint8_t hop_index) 
        : dwell_time(dwell_time), hop_set(hop_set), 
          hop_pattern(hop_pattern), hop_index(hop_index) {}

        static fh_params_set from_option(const option& opt);
    };
    
    struct cf_params_set {
        uint8_t cfp_count, cfp_period;
        uint16_t cfp_max_duration, cfp_dur_remaining;
        
        cf_params_set()
        : cfp_count(0), cfp_period(0), cfp_max_duration(0), cfp_dur_remaining(0) {}
        
        cf_params_set(uint8_t cfp_count, 
                      uint8_t cfp_period,
                      uint16_t cfp_max_duration,
                      uint16_t cfp_dur_remaining) 
        : cfp_count(cfp_count), cfp_period(cfp_period), 
          cfp_max_duration(cfp_max_duration), 
          cfp_dur_remaining(cfp_dur_remaining) {}

        static cf_params_set from_option(const option& opt);
    };
    
    struct ibss_dfs_params {
        static const size_t minimum_size = address_type::address_size + sizeof(uint8_t) + 2 * sizeof(uint8_t);
        
        address_type dfs_owner;
        uint8_t recovery_interval; 
        channel_map_type channel_map;
       
        ibss_dfs_params() : recovery_interval(0) {}
       
        ibss_dfs_params(const address_type& addr, 
                        uint8_t recovery_interval,
                        const channel_map_type& channel_map)
        : dfs_owner(addr), recovery_interval(recovery_interval),
          channel_map(channel_map) {}

        static ibss_dfs_params from_option(const option& opt);
    };
    
    struct country_params {
        // String identifier: 3 bytes
        static const size_t minimum_size = 3 + sizeof(uint8_t) * 3;
        
        std::string country;
        byte_array first_channel, number_channels, max_transmit_power;
        
        country_params() {}
        
        country_params(const std::string& country, 
                       const byte_array& first,
                       const byte_array& number,
                       const byte_array& max) 
        : country(country), first_channel(first), number_channels(number),
          max_transmit_power(max) {}

        static country_params from_option(const option& opt);
    };
    
    struct fh_pattern_type {
        static const size_t minimum_size = sizeof(uint8_t) * 4;
        
        uint8_t flag, number_of_sets, modulus, offset;
        byte_array random_table;
        
        fh_pattern_type()
        : flag(0), number_of_sets(0), modulus(0), offset(0) {}
        
        fh_pattern_type(uint8_t flag, 
                        uint8_t sets,
                        uint8_t modulus,
                        uint8_t offset,
                        const byte_array& table) 
        : flag(flag), number_of_sets(sets), modulus(modulus), 
          offset(offset), random_table(table) {}

        static fh_pattern_type from_option(const option& opt);
    };
    
    struct channel_switch_type {
        uint8_t switch_mode, new_channel, switch_count;
        
        channel_switch_type()
        : switch_mode(0), new_channel(0), switch_count(0) {}
        
        channel_switch_type(uint8_t mode, 
                            uint8_t channel,
                            uint8_t count)
        : switch_mode(mode), new_channel(channel), switch_count(count) { }

        static channel_switch_type from_option(const option& opt);
    };
    
    struct quiet_type {
        uint8_t quiet_count, quiet_period;
        uint16_t quiet_duration, quiet_offset;
        
        quiet_type() 
        : quiet_count(0), quiet_period(0), quiet_duration(0), quiet_offset(0) {}
        
        quiet_type(uint8_t count, 
                   uint8_t period,
                   uint16_t duration,
                   uint16_t offset)
        : quiet_count(count), quiet_period(period), 
        quiet_duration(duration), quiet_offset(offset) {}

        static quiet_type from_option(const option& opt);
    };

    struct bss_load_type {
        uint16_t station_count;
        uint16_t available_capacity;
        uint8_t channel_utilization;
        
        bss_load_type() 
        : station_count(0), available_capacity(0), channel_utilization(0) {}
        
        bss_load_type(uint16_t count, uint8_t utilization, uint16_t capacity) 
        : station_count(count), available_capacity(capacity),
        channel_utilization(utilization) {}

        static bss_load_type from_option(const option& opt);
    };
    
    struct tim_type {
        uint8_t dtim_count, dtim_period, bitmap_control;
        byte_array partial_virtual_bitmap;
        
        tim_type()
        : dtim_count(0), dtim_period(0), bitmap_control(0) {}
        
        tim_type(uint8_t count, 
                 uint8_t period,
                 uint8_t control,
                 const byte_array& bitmap) 
        : dtim_count(count), dtim_period(period), bitmap_control(control),
        partial_virtual_bitmap(bitmap) {}

        static tim_type from_option(const option& opt);
    };

    struct vendor_specific_type {
        typedef HWAddress<3> oui_type;

        oui_type oui;
        byte_array data;

        vendor_specific_type(const oui_type& oui = oui_type(),
                             const byte_array& data = byte_array())
        : oui(oui), data(data) { }

        static vendor_specific_type from_bytes(const uint8_t* buffer, uint32_t sz);
    };
    
    typedef uint8_t qos_capability_type;

    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
    }

    const 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);

    // Option setter helpers

    void ssid(const std::string& new_ssid);

    void rsn_information(const RSNInformation& info);

    void supported_rates(const rates_type& new_rates);

    void extended_supported_rates(const rates_type& new_rates);

    void qos_capability(qos_capability_type new_qos_capability);

    void power_capability(uint8_t min_power, uint8_t max_power);

    void supported_channels(const channels_type& new_channels);

    void edca_parameter_set(uint32_t ac_be, uint32_t ac_bk, uint32_t ac_vi, uint32_t ac_vo);

    void request_information(const request_info_type elements);

    void fh_parameter_set(const fh_params_set& fh_params);

    void ds_parameter_set(uint8_t current_channel);

    void cf_parameter_set(const cf_params_set& params);

    void ibss_parameter_set(uint16_t atim_window);

    void ibss_dfs(const ibss_dfs_params& params);

    void country(const country_params& params);

    void fh_parameters(uint8_t prime_radix, uint8_t number_channels);

    void fh_pattern_table(const fh_pattern_type& params);

    void power_constraint(uint8_t local_power_constraint);

    void channel_switch(const channel_switch_type& data);

    void quiet(const quiet_type& data);

    void tpc_report(uint8_t transmit_power, uint8_t link_margin);

    void erp_information(uint8_t value);

    void bss_load(const bss_load_type& data);

    void tim(const tim_type& data);

    void challenge_text(const std::string& text);

    void vendor_specific(const vendor_specific_type& data);
    
    // Option searching helpers
    
    RSNInformation rsn_information() const;
    
    std::string ssid() const;

    rates_type supported_rates() const;

    rates_type extended_supported_rates() const;

    qos_capability_type qos_capability() const;

    std::pair<uint8_t, uint8_t> power_capability() const;
    
    channels_type supported_channels() const;
    
    request_info_type request_information() const;
    
    fh_params_set fh_parameter_set() const;
    
    uint8_t ds_parameter_set() const;

    cf_params_set cf_parameter_set() const;
    
    
    uint16_t ibss_parameter_set() const;
    
    ibss_dfs_params ibss_dfs() const;
    
    country_params country() const;
    
    std::pair<uint8_t, uint8_t> fh_parameters() const;
    
    fh_pattern_type fh_pattern_table() const;
    
    uint8_t power_constraint() const;
    
    channel_switch_type channel_switch() const;
    
    quiet_type quiet() const;
    
    std::pair<uint8_t, uint8_t> tpc_report() const;
    
    uint8_t erp_information() const;
    
    bss_load_type bss_load() const;
    
    tim_type tim() const;
    
    std::string challenge_text() const;
    
    vendor_specific_type vendor_specific() const;

    // ************************

    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);
    }
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;

    
    Dot11ManagementFrame(const address_type& dst_hw_addr = address_type(), 
                         const address_type& src_hw_addr = address_type());
    
    Dot11ManagementFrame(const uint8_t* buffer, uint32_t total_sz);

    void write_ext_header(Memory::OutputMemoryStream& stream);

    uint32_t management_frame_size() { 
        return Dot11ManagementFrame::header_size();
    }
private:
    static std::vector<uint8_t> serialize_rates(const rates_type& rates);
    static rates_type deserialize_rates(const option* option);
    
    template<typename T>
    T search_and_convert(OptionTypes opt_type) const {
        const option* opt = search_option(opt_type);
        if (!opt) {
            throw option_not_found();
        }
        return opt->to<T>();
    }

    dot11_extended_header ext_header_;
    address_type addr4_;
};

} // namespace Tins

#endif // TINS_DOT11_DOT11_MGMT_H