Fixed merge conflicts

include/ieee802-11.h

@@ -25,6 +25,7 @@
 #include <list>
 #include <stdint.h>
 #include <stdexcept>
+#include <utility>
 
 #include "pdu.h"
 #include "utils.h"
@@ -1194,6 +1195,128 @@ namespace Tins {
         DisassocBody _body;
     };
 
+    /**
+     * \brief Class representing an Association Request frame in the IEEE 802.11 Protocol.
+     *
+     */
+    class IEEE802_11_Assoc_Request : public ManagementFrame {
+
+    public:
+
+        /**
+         * \brief Default constructor for the Association Request frame.
+         *
+         */
+        IEEE802_11_Assoc_Request();
+
+        /**
+         * \brief Constructor for creating a 802.11 Association Request.
+         *
+         * Constructor that builds a 802.11 Association Request taking the interface name,
+         * destination's and source's MAC.
+         *
+         * \param iface string containing the interface's name from where to send the packet.
+         * \param dst_hw_addr uint8_t array of 6 bytes containing the destination's MAC(optional).
+         * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional).
+         */
+        IEEE802_11_Assoc_Request(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error);
+
+        /**
+         * \brief Getter for the Capabilities Information.
+         *
+         * \return CapabilityInformation Structure in a CapabilityInformation&.
+         */
+        inline const CapabilityInformation& capabilities() const { return this->_body.capability;}
+
+        /**
+         * \brief Getter for the Capabilities Information.
+         *
+         * \return CapabilityInformation Structure in a CapabilityInformation&.
+         */
+        inline CapabilityInformation& capabilities() { return this->_body.capability;}
+
+        /**
+         * \brief Getter for the listen interval.
+         *
+         * \return The listen interval in an uint16_t.
+         */
+        inline uint16_t listen_interval() const { return this->_body.listen_interval; }
+
+        /**
+         * \brief Setter for the listen interval.
+         *
+         * \param new_listen_interval uint16_t with the new listen interval.
+         */
+        void listen_interval(uint16_t new_listen_interval);
+
+        /**
+         * \brief Helper method to set the essid.
+         *
+         * \param new_ssid The ssid to be set.
+         */
+        void ssid(const std::string &new_ssid);
+
+        /**
+         * \brief Helper method to set the supported rates.
+         *
+         * \param new_rates A list of rates to be set.
+         */
+        void supported_rates(const std::list<float> &new_rates);
+
+        /**
+         * \brief Helper method to set the extended supported rates.
+         *
+         * \param new_rates A list of rates to be set.
+         */
+        void extended_supported_rates(const std::list<float> &new_rates);
+
+        /**
+         * \brief Helper method to set the power capabilities.
+         *
+         * \param min_power uint8_t indicating the minimum transmiting power capability.
+         * \param max_power uint8_t indicating the maximum transmiting power capability.
+         */
+        void power_capabilities(uint8_t min_power, uint8_t max_power);
+
+        /**
+         * \brief Helper method to set the supported channels.
+         *
+         * \param new_channels A list of channels to be set.
+         */
+        void supported_channels(const std::list<std::pair<uint8_t, uint8_t> > &new_channels);
+
+        /**
+         * \brief Helper method to set the RSN information option.
+         *
+         * \param info The RSNInformation structure to be set.
+         */
+        void rsn_information(const RSNInformation& info);
+
+        /**
+         * \brief Helper method to set the QoS capabilities.
+         *
+         * \param new_qos_capabilities uint8_t with the capabilities.
+         */
+        void qos_capabilities(uint8_t new_qos_capabilities);
+
+        /**
+         * \brief Returns the frame's header length.
+         *
+         * \return An uint32_t with the header's size.
+         * \sa PDU::header_size()
+         */
+        uint32_t header_size() const;
+    private:
+        struct AssocReqBody {
+            CapabilityInformation capability;
+            uint16_t listen_interval;
+        };
+
+        uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz);
+
+        AssocReqBody _body;
+    };
+
 }
 
 #endif

src/ieee802-11.cpp

@@ -22,6 +22,8 @@
 #include <cassert>
 #include <cstring>
 #include <stdexcept>
+#include <algorithm> 
+#include <utility>
 #ifndef WIN32
     #include <net/ethernet.h>
     #include <netpacket/packet.h>
@@ -70,16 +72,16 @@ Tins::IEEE802_11::IEEE802_11(const ieee80211_header *header_ptr) : PDU(ETHERTYPE
 }
 
 Tins::IEEE802_11::IEEE802_11(const uint8_t *buffer, uint32_t total_sz) : PDU(ETHERTYPE_IP), _options_size(0) {
-    if(total_sz < sizeof(_header))
+    if(total_sz < sizeof(_header.control))
         throw std::runtime_error("Not enough size for an IEEE 802.11 header in the buffer.");
-    std::memcpy(&_header, buffer, sizeof(_header));
-    buffer += sizeof(_header);
-    total_sz -= sizeof(_header);
+    uint32_t sz = std::min(sizeof(_header), total_sz);
+    std::memcpy(&_header, buffer, sz);
+    buffer += sz;
+    total_sz -= sz;
     if(type() == 0 && subtype() < 4) {
         // It's a data packet
         inner_pdu(new Tins::SNAP(buffer, total_sz));
     }
-    // subclass specific parsing missing too.
 }
 
 Tins::IEEE802_11::~IEEE802_11() {
@@ -244,12 +246,16 @@ void Tins::IEEE802_11::write_serialization(uint8_t *buffer, uint32_t total_sz, c
 }
 
 Tins::PDU *Tins::IEEE802_11::from_bytes(const uint8_t *buffer, uint32_t total_sz) {
-    if(total_sz < sizeof(ieee80211_header)) 
+    // We only need the control field, the length of the PDU will depend on the flags set.
+    if(total_sz < sizeof(ieee80211_header::control)) 
         throw std::runtime_error("Not enough size for a IEEE 802.11 header in the buffer.");
     const ieee80211_header *hdr = (const ieee80211_header*)buffer;
     PDU *ret = 0;
-    if(hdr->control.type == 0 && hdr->control.subtype == 8)
+    if(hdr->control.type == 0 && hdr->control.subtype == 8) {
+        if(total_sz < sizeof(_header))
+            throw std::runtime_error("Not enough size for an IEEE 802.11 header in the buffer.");
         ret = new IEEE802_11_Beacon(buffer, total_sz);
+    }
     else
         ret = new IEEE802_11(buffer, total_sz);
     return ret;
@@ -261,7 +267,7 @@ Tins::PDU *Tins::IEEE802_11::from_bytes(const uint8_t *buffer, uint32_t total_sz
  */
 
 Tins::ManagementFrame::ManagementFrame(const uint8_t *buffer, uint32_t total_sz) : IEEE802_11(buffer, total_sz) {
-    
+
 }
 
 Tins::ManagementFrame::ManagementFrame(const uint8_t *dst_hw_addr, const uint8_t *src_hw_addr) : IEEE802_11(dst_hw_addr, src_hw_addr) {
@@ -352,7 +358,7 @@ bool Tins::IEEE802_11_Beacon::rsn_information(RSNInformation *rsn) {
     buffer += sizeof(uint16_t);
     rsn->group_suite((RSNInformation::CypherSuites)*(uint32_t*)buffer);
     buffer += sizeof(uint32_t);
-    
+
     bytes_left -= (sizeof(uint16_t) << 1) + sizeof(uint32_t);
     if(bytes_left < sizeof(uint16_t))
         return false;
@@ -481,3 +487,88 @@ Tins::RSNInformation Tins::RSNInformation::wpa2_psk() {
     info.add_akm_cypher(RSNInformation::PSK);
     return info;
 }
+
+Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request() {
+    this->subtype(IEEE802_11::ASSOC_REQ);
+    memset(&_body, 0, sizeof(_body));
+}
+
+Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request(const std::string& iface,
+                                           const uint8_t* dst_hw_addr,
+                                           const uint8_t* src_hw_addr) throw (std::runtime_error) : ManagementFrame(iface, dst_hw_addr, src_hw_addr){
+    this->subtype(IEEE802_11::ASSOC_REQ);
+    memset(&_body, 0, sizeof(_body));
+}
+
+void Tins::IEEE802_11_Assoc_Request::listen_interval(uint16_t new_listen_interval) {
+    this->_body.listen_interval = new_listen_interval;
+}
+
+void Tins::IEEE802_11_Assoc_Request::ssid(const std::string &new_ssid) {
+    add_tagged_option(IEEE802_11::SSID, new_ssid.size(), (const uint8_t*)new_ssid.c_str());
+}
+
+void Tins::IEEE802_11_Assoc_Request::supported_rates(const std::list<float> &new_rates) {
+    uint8_t *buffer = new uint8_t[new_rates.size()], *ptr = buffer;
+    for(std::list<float>::const_iterator it = new_rates.begin(); it != new_rates.end(); ++it) {
+        uint8_t result = 0x80, left = *it / 0.5;
+        if(*it - left > 0)
+            left++;
+        *(ptr++) = (result | left);
+    }
+    add_tagged_option(SUPPORTED_RATES, new_rates.size(), buffer);
+    delete[] buffer;
+}
+
+void Tins::IEEE802_11_Assoc_Request::extended_supported_rates(const std::list<float> &new_rates) {
+    uint8_t *buffer = new uint8_t[new_rates.size()], *ptr = buffer;
+    for(std::list<float>::const_iterator it = new_rates.begin(); it != new_rates.end(); ++it) {
+        uint8_t result = 0x80, left = *it / 0.5;
+        if(*it - left > 0)
+            left++;
+        *(ptr++) = (result | left);
+    }
+    add_tagged_option(EXT_SUPPORTED_RATES, new_rates.size(), buffer);
+    delete[] buffer;
+}
+
+void Tins::IEEE802_11_Assoc_Request::power_capabilities(uint8_t min_power, uint8_t max_power) {
+    uint8_t buffer[2];
+    buffer[0] = min_power;
+    buffer[1] = max_power;
+    add_tagged_option(POWER_CAPABILITY, 2, buffer);
+}
+
+void Tins::IEEE802_11_Assoc_Request::supported_channels(const std::list<pair<uint8_t, uint8_t> > &new_channels) {
+
+    uint8_t* buffer = new uint8_t[new_channels.size() * 2];
+    uint8_t* ptr = buffer;
+    for(std::list<pair<uint8_t, uint8_t> >::const_iterator it = new_channels.begin(); it != new_channels.end(); ++it) {
+        *(ptr++) = it->first;
+        *(ptr++) = it->second;
+    }
+    add_tagged_option(SUPPORTED_CHANNELS, new_channels.size() * 2, buffer);
+
+}
+
+void Tins::IEEE802_11_Assoc_Request::rsn_information(const RSNInformation& info) {
+    uint32_t size;
+    uint8_t *buffer = info.serialize(size);
+    add_tagged_option(RSN, size, buffer);
+    delete[] buffer;
+}
+
+void Tins::IEEE802_11_Assoc_Request::qos_capabilities(uint8_t new_qos_capabilities) {
+    add_tagged_option(QOS_CAPABILITY, 1, &new_qos_capabilities);
+}
+
+uint32_t Tins::IEEE802_11_Assoc_Request::header_size() const {
+    return IEEE802_11::header_size() + sizeof(AssocReqBody);
+}
+
+uint32_t Tins::IEEE802_11_Assoc_Request::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) {
+    uint32_t sz = sizeof(AssocReqBody);
+    assert(sz <= total_sz);
+    memcpy(buffer, &this->_body, sz);
+    return sz;
+}