From 477a757f5a6e70c1486cf1684645ce19333ed5e1 Mon Sep 17 00:00:00 2001 From: Matias Fontanini Date: Sun, 4 Sep 2011 10:19:58 -0300 Subject: [PATCH] Renamed IEEE802_11 and all subclasses to Dot11 --- include/{ieee802-11.h => dot11.h} | 130 ++++++------ include/pdu.h | 2 +- include/tins.h | 2 +- src/{ieee802-11.cpp => dot11.cpp} | 332 +++++++++++++++--------------- src/eapol.cpp | 4 +- src/radiotap.cpp | 6 +- 6 files changed, 238 insertions(+), 238 deletions(-) rename include/{ieee802-11.h => dot11.h} (91%) rename src/{ieee802-11.cpp => dot11.cpp} (55%) diff --git a/include/ieee802-11.h b/include/dot11.h similarity index 91% rename from include/ieee802-11.h rename to include/dot11.h index a813af8..0cd404c 100644 --- a/include/ieee802-11.h +++ b/include/dot11.h @@ -19,8 +19,8 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __IEEE802_11_h -#define __IEEE802_11_h +#ifndef __DOT_11 +#define __DOT_11 #include #include @@ -35,7 +35,7 @@ namespace Tins { /** * \brief Class representing an 802.11 frame. */ - class IEEE802_11 : public PDU { + class Dot11 : public PDU { public: /** * \brief Broadcast hardware address. @@ -145,7 +145,7 @@ namespace Tins { /** * \brief IEEE 802.11 options struct. */ - struct IEEE802_11_Option { + struct Dot11_Option { /** * \brief The option number. */ @@ -160,7 +160,7 @@ namespace Tins { uint8_t *value; /** - * \brief Creates an instance of IEEE802_11_Option. + * \brief Creates an instance of Dot11_Option. * * The option's value is copied, therefore the user should * manually free any memory pointed by the "val" parameter. @@ -168,7 +168,7 @@ namespace Tins { * \param len The length of the option's value in bytes. * \param val The option's value. */ - IEEE802_11_Option(uint8_t opt, uint8_t len, const uint8_t *val); + Dot11_Option(uint8_t opt, uint8_t len, const uint8_t *val); }; /** @@ -180,7 +180,7 @@ namespace Tins { * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional). * \param child PDU* with the PDU contained by the 802.11 PDU (optional). */ - IEEE802_11(const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); + Dot11(const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); /** * \brief Constructor for creating a 802.11 PDU @@ -193,7 +193,7 @@ namespace Tins { * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional). * \param child PDU* with the PDU contained by the 802.11 PDU (optional). */ - IEEE802_11(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0) throw (std::runtime_error); + Dot11(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0) throw (std::runtime_error); /** * \brief Constructor for creating an 802.11 PDU @@ -206,7 +206,7 @@ namespace Tins { * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional). * \param child PDU* with the PDU contained by the 802.11 PDU (optional). */ - IEEE802_11(uint32_t iface_index, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); + Dot11(uint32_t iface_index, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); /** * \brief Constructor which creates an 802.11 object from a buffer and adds all identifiable @@ -214,24 +214,24 @@ namespace Tins { * \param buffer The buffer from which this PDU will be constructed. * \param total_sz The total size of the buffer. */ - IEEE802_11(const uint8_t *buffer, uint32_t total_sz); + Dot11(const uint8_t *buffer, uint32_t total_sz); /** * \brief Copy constructor. */ - IEEE802_11(const IEEE802_11 &other); + Dot11(const Dot11 &other); /** - * \brief IEEE802_11 destructor. + * \brief Dot11 destructor. * * Releases the memory allocated for tagged options. */ - ~IEEE802_11(); + ~Dot11(); /** * \brief Copy assignment operator. */ - IEEE802_11 &operator= (const IEEE802_11 &other); + Dot11 &operator= (const Dot11 &other); /** * \brief Getter for the protocol version. @@ -507,7 +507,7 @@ namespace Tins { bool send(PacketSender* sender); /** - * \brief Adds a new option to this IEEE802_11 PDU. + * \brief Adds a new option to this Dot11 PDU. * * This copies the value buffer. * \param opt The option identifier. @@ -521,16 +521,16 @@ namespace Tins { * \param opt The option identifier. * \return The option found, or 0 if no such option has been set. */ - const IEEE802_11_Option *lookup_option(TaggedOption opt) const; + const Dot11_Option *lookup_option(TaggedOption opt) const; /** * \brief Getter for the PDU's type. * \sa PDU::pdu_type */ - PDUType pdu_type() const { return PDU::IEEE802_11; } + PDUType pdu_type() const { return PDU::DOT11; } /** - * \brief Allocates an IEEE802_11 PDU from a buffer. + * \brief Allocates an Dot11 PDU from a buffer. * \param buffer The buffer from which to take the PDU data. * \param total_sz The total size of the buffer. * \return The allocated PDU. @@ -539,7 +539,7 @@ namespace Tins { protected: virtual uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { return 0; } void parse_tagged_parameters(const uint8_t *buffer, uint32_t total_sz); - void copy_80211_fields(const IEEE802_11 *other); + void copy_80211_fields(const Dot11 *other); protected: /** * Struct that represents the 802.11 header @@ -589,7 +589,7 @@ namespace Tins { } __attribute__((__packed__)); private: - IEEE802_11(const ieee80211_header *header_ptr); + Dot11(const ieee80211_header *header_ptr); void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent); @@ -597,7 +597,7 @@ namespace Tins { ieee80211_header _header; uint8_t _addr4[6]; uint32_t _iface_index, _options_size; - std::list _options; + std::list _options; }; /** @@ -711,7 +711,7 @@ namespace Tins { /** * \brief Abstract class that englobes all Management frames in the 802.11 protocol. */ - class ManagementFrame : public IEEE802_11 { + class Dot11ManagementFrame : public Dot11 { public: @@ -996,15 +996,15 @@ namespace Tins { protected: /** - * \brief Constructor which creates a ManagementFrame object from a buffer and adds all identifiable + * \brief Constructor which creates a Dot11ManagementFrame object from a buffer and adds all identifiable * PDUs found in the buffer as children of this one. * \param buffer The buffer from which this PDU will be constructed. * \param total_sz The total size of the buffer. */ - ManagementFrame(const uint8_t *dst_hw_addr = 0, const uint8_t *src_hw_addr = 0); - ManagementFrame(const std::string &iface, const uint8_t *dst_hw_addr, const uint8_t *src_hw_addr) throw (std::runtime_error); - ManagementFrame(const uint8_t *buffer, uint32_t total_sz); - ManagementFrame(const ManagementFrame &other); + Dot11ManagementFrame(const uint8_t *dst_hw_addr = 0, const uint8_t *src_hw_addr = 0); + Dot11ManagementFrame(const std::string &iface, const uint8_t *dst_hw_addr, const uint8_t *src_hw_addr) throw (std::runtime_error); + Dot11ManagementFrame(const uint8_t *buffer, uint32_t total_sz); + Dot11ManagementFrame(const Dot11ManagementFrame &other); void ssid(const std::string &new_ssid); void rates(const std::list &new_rates); @@ -1028,7 +1028,7 @@ namespace Tins { * \brief Class representing a Beacon in the IEEE 802.11 Protocol. * */ - class IEEE802_11_Beacon : public ManagementFrame { + class Dot11Beacon : public Dot11ManagementFrame { public: @@ -1037,7 +1037,7 @@ namespace Tins { * \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_Beacon(const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0); + Dot11Beacon(const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0); /** * \brief Constructor for creating a 802.11 Beacon. @@ -1049,26 +1049,26 @@ namespace Tins { * \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_Beacon(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); + Dot11Beacon(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); /** - * \brief Constructor which creates a IEEE802_11_Beacon object from a buffer and adds + * \brief Constructor which creates a Dot11Beacon object from a buffer and adds * all identifiable PDUs found in the buffer as children of this one. * * \param buffer The buffer from which this PDU will be constructed. * \param total_sz The total size of the buffer. */ - IEEE802_11_Beacon(const uint8_t *buffer, uint32_t total_sz); + Dot11Beacon(const uint8_t *buffer, uint32_t total_sz); /** * \brief Copy constructor. */ - IEEE802_11_Beacon(const IEEE802_11_Beacon &other); + Dot11Beacon(const Dot11Beacon &other); /** * \brief Copy assignment operator. */ - IEEE802_11_Beacon &operator= (const IEEE802_11_Beacon &other); + Dot11Beacon &operator= (const Dot11Beacon &other); /** * \brief Getter for the timestamp field. @@ -1168,7 +1168,7 @@ namespace Tins { CapabilityInformation capability; } __attribute__((__packed__)); - void copy_fields(const IEEE802_11_Beacon *other); + void copy_fields(const Dot11Beacon *other); uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz); @@ -1179,7 +1179,7 @@ namespace Tins { * \brief Class representing a Disassociation frame in the IEEE 802.11 Protocol. * */ - class IEEE802_11_Disassoc : public ManagementFrame { + class Dot11Disassoc : public Dot11ManagementFrame { public: @@ -1187,7 +1187,7 @@ namespace Tins { * \brief Default constructor for the Disassociation frame. * */ - IEEE802_11_Disassoc(); + Dot11Disassoc(); /** * \brief Constructor for creating a 802.11 Disassociation. @@ -1199,17 +1199,17 @@ namespace Tins { * \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_Disassoc(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); + Dot11Disassoc(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); /** * \brief Copy constructor. */ - IEEE802_11_Disassoc(const IEEE802_11_Disassoc &other); + Dot11Disassoc(const Dot11Disassoc &other); /** * \brief Copy assignment operator. */ - IEEE802_11_Disassoc &operator= (const IEEE802_11_Disassoc &other); + Dot11Disassoc &operator= (const Dot11Disassoc &other); /** * \brief Getter for the reason code. @@ -1237,7 +1237,7 @@ namespace Tins { uint16_t reason_code; }; - void copy_fields(const IEEE802_11_Disassoc *other); + void copy_fields(const Dot11Disassoc *other); uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz); @@ -1248,7 +1248,7 @@ namespace Tins { * \brief Class representing an Association Request frame in the IEEE 802.11 Protocol. * */ - class IEEE802_11_Assoc_Request : public ManagementFrame { + class Dot11AssocRequest : public Dot11ManagementFrame { public: @@ -1256,7 +1256,7 @@ namespace Tins { * \brief Default constructor for the Association Request frame. * */ - IEEE802_11_Assoc_Request(); + Dot11AssocRequest(); /** * \brief Constructor for creating a 802.11 Association Request. @@ -1268,26 +1268,26 @@ namespace Tins { * \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); + Dot11AssocRequest(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); /** - * \brief Constructor which creates a IEEE802_11_Assoc_Request object from a + * \brief Constructor which creates a Dot11AssocRequest object from a * buffer and adds all identifiable PDUs found in the buffer as children of this one. * * \param buffer The buffer from which this PDU will be constructed. * \param total_sz The total size of the buffer. */ - IEEE802_11_Assoc_Request(const uint8_t *buffer, uint32_t total_sz); + Dot11AssocRequest(const uint8_t *buffer, uint32_t total_sz); /** * \brief Copy constructor. */ - IEEE802_11_Assoc_Request(const IEEE802_11_Assoc_Request &other); + Dot11AssocRequest(const Dot11AssocRequest &other); /** * \brief Copy assignment operator. */ - IEEE802_11_Assoc_Request &operator= (const IEEE802_11_Assoc_Request &other); + Dot11AssocRequest &operator= (const Dot11AssocRequest &other); /** * \brief Getter for the Capabilities Information. @@ -1380,7 +1380,7 @@ namespace Tins { uint16_t listen_interval; }; - void copy_fields(const IEEE802_11_Assoc_Request *other); + void copy_fields(const Dot11AssocRequest *other); uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz); AssocReqBody _body; @@ -1390,7 +1390,7 @@ namespace Tins { * \brief Class representing an Association Response frame in the IEEE 802.11 Protocol. * */ - class IEEE802_11_Assoc_Response : public ManagementFrame { + class Dot11AssocResponse : public Dot11ManagementFrame { public: @@ -1398,7 +1398,7 @@ namespace Tins { * \brief Default constructor for the Association Response frame. * */ - IEEE802_11_Assoc_Response(); + Dot11AssocResponse(); /** * \brief Constructor for creating a 802.11 Association Response. @@ -1410,26 +1410,26 @@ namespace Tins { * \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_Response(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); + Dot11AssocResponse(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0) throw (std::runtime_error); /** - * \brief Constructor which creates a IEEE802_11_Assoc_Response object from a + * \brief Constructor which creates a Dot11AssocResponse object from a * buffer and adds all identifiable PDUs found in the buffer as children of this one. * * \param buffer The buffer from which this PDU will be constructed. * \param total_sz The total size of the buffer. */ - IEEE802_11_Assoc_Response(const uint8_t *buffer, uint32_t total_sz); + Dot11AssocResponse(const uint8_t *buffer, uint32_t total_sz); /** * \brief Copy constructor. */ - IEEE802_11_Assoc_Response(const IEEE802_11_Assoc_Response &other); + Dot11AssocResponse(const Dot11AssocResponse &other); /** * \brief Copy assignment operator */ - IEEE802_11_Assoc_Response &operator= (const IEEE802_11_Assoc_Response &other); + Dot11AssocResponse &operator= (const Dot11AssocResponse &other); /** * \brief Getter for the Capabilities Information. @@ -1511,13 +1511,13 @@ namespace Tins { uint16_t aid; }; - void copy_fields(const IEEE802_11_Assoc_Response *other); + void copy_fields(const Dot11AssocResponse *other); uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz); AssocRespBody _body; }; - class IEEE802_11_QoS_Data : public IEEE802_11 { + class Dot11QoSData : public Dot11 { public: @@ -1530,7 +1530,7 @@ namespace Tins { * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional). * \param child PDU* with the PDU contained by the 802.11 PDU (optional). */ - IEEE802_11_QoS_Data(const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); + Dot11QoSData(const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); /** * \brief Constructor for creating a 802.11 QoS Data PDU @@ -1543,7 +1543,7 @@ namespace Tins { * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional). * \param child PDU* with the PDU contained by the 802.11 PDU (optional). */ - IEEE802_11_QoS_Data(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0) throw (std::runtime_error); + Dot11QoSData(const std::string& iface, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0) throw (std::runtime_error); /** * \brief Constructor for creating an 802.11 QoS Data PDU @@ -1556,7 +1556,7 @@ namespace Tins { * \param src_hw_addr uint8_t array of 6 bytes containing the source's MAC(optional). * \param child PDU* with the PDU contained by the 802.11 PDU (optional). */ - IEEE802_11_QoS_Data(uint32_t iface_index, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); + Dot11QoSData(uint32_t iface_index, const uint8_t* dst_hw_addr = 0, const uint8_t* src_hw_addr = 0, PDU* child = 0); /** * \brief Constructor which creates an 802.11 QoS Data object from a buffer and adds all identifiable @@ -1564,17 +1564,17 @@ namespace Tins { * \param buffer The buffer from which this PDU will be constructed. * \param total_sz The total size of the buffer. */ - IEEE802_11_QoS_Data(const uint8_t *buffer, uint32_t total_sz); + Dot11QoSData(const uint8_t *buffer, uint32_t total_sz); /** * \brief Copy constructor. */ - IEEE802_11_QoS_Data(const IEEE802_11_QoS_Data &other); + Dot11QoSData(const Dot11QoSData &other); /** * \brief Copy assignment operator. */ - IEEE802_11_QoS_Data &operator= (const IEEE802_11_QoS_Data &other); + Dot11QoSData &operator= (const Dot11QoSData &other); /** * \brief Getter for the qos_control field. @@ -1598,7 +1598,7 @@ namespace Tins { */ uint32_t header_size() const; private: - void copy_fields(const IEEE802_11_QoS_Data *other); + void copy_fields(const Dot11QoSData *other); uint32_t write_fixed_parameters(uint8_t *buffer, uint32_t total_sz); diff --git a/include/pdu.h b/include/pdu.h index b594363..c6cc06a 100644 --- a/include/pdu.h +++ b/include/pdu.h @@ -52,7 +52,7 @@ namespace Tins { enum PDUType { RAW, ETHERNET_II, - IEEE802_11, + DOT11, SNAP, RADIOTAP, IP, diff --git a/include/tins.h b/include/tins.h index a2254a0..39247de 100644 --- a/include/tins.h +++ b/include/tins.h @@ -28,7 +28,7 @@ #include "eapol.h" #include "ethernetII.h" #include "icmp.h" -#include "ieee802-11.h" +#include "dot11.h" #include "ip.h" #include "packetsender.h" #include "pdu.h" diff --git a/src/ieee802-11.cpp b/src/dot11.cpp similarity index 55% rename from src/ieee802-11.cpp rename to src/dot11.cpp index d19bd27..45e17a5 100644 --- a/src/ieee802-11.cpp +++ b/src/dot11.cpp @@ -29,7 +29,7 @@ #include #include #endif -#include "ieee802-11.h" +#include "dot11.h" #include "rawpdu.h" #include "radiotap.h" #include "sniffer.h" @@ -38,9 +38,9 @@ using namespace std; -const uint8_t *Tins::IEEE802_11::BROADCAST = (const uint8_t*)"\xff\xff\xff\xff\xff\xff"; +const uint8_t *Tins::Dot11::BROADCAST = (const uint8_t*)"\xff\xff\xff\xff\xff\xff"; -Tins::IEEE802_11::IEEE802_11(const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : PDU(ETHERTYPE_IP, child), _options_size(0) { +Tins::Dot11::Dot11(const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : PDU(ETHERTYPE_IP, child), _options_size(0) { memset(&this->_header, 0, sizeof(ieee80211_header)); if(dst_hw_addr) this->addr1(dst_hw_addr); @@ -48,7 +48,7 @@ Tins::IEEE802_11::IEEE802_11(const uint8_t* dst_hw_addr, const uint8_t* src_hw_a this->addr2(src_hw_addr); } -Tins::IEEE802_11::IEEE802_11(const std::string& iface, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) throw (std::runtime_error) : PDU(ETHERTYPE_IP, child), _options_size(0) { +Tins::Dot11::Dot11(const std::string& iface, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) throw (std::runtime_error) : PDU(ETHERTYPE_IP, child), _options_size(0) { memset(&this->_header, 0, sizeof(ieee80211_header)); if(dst_hw_addr) this->addr1(dst_hw_addr); @@ -58,7 +58,7 @@ Tins::IEEE802_11::IEEE802_11(const std::string& iface, const uint8_t* dst_hw_add } -Tins::IEEE802_11::IEEE802_11(uint32_t iface_index, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : PDU(ETHERTYPE_IP, child), _options_size(0) { +Tins::Dot11::Dot11(uint32_t iface_index, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : PDU(ETHERTYPE_IP, child), _options_size(0) { memset(&this->_header, 0, sizeof(ieee80211_header)); if(dst_hw_addr) this->addr1(dst_hw_addr); @@ -67,11 +67,11 @@ Tins::IEEE802_11::IEEE802_11(uint32_t iface_index, const uint8_t* dst_hw_addr, c this->iface(iface_index); } -Tins::IEEE802_11::IEEE802_11(const ieee80211_header *header_ptr) : PDU(ETHERTYPE_IP) { +Tins::Dot11::Dot11(const ieee80211_header *header_ptr) : PDU(ETHERTYPE_IP) { } -Tins::IEEE802_11::IEEE802_11(const uint8_t *buffer, uint32_t total_sz) : PDU(ETHERTYPE_IP), _options_size(0) { +Tins::Dot11::Dot11(const uint8_t *buffer, uint32_t total_sz) : PDU(ETHERTYPE_IP), _options_size(0) { if(total_sz < sizeof(_header.control)) throw std::runtime_error("Not enough size for an IEEE 802.11 header in the buffer."); uint32_t sz = std::min((uint32_t)sizeof(_header), total_sz); @@ -84,24 +84,24 @@ Tins::IEEE802_11::IEEE802_11(const uint8_t *buffer, uint32_t total_sz) : PDU(ETH } } -Tins::IEEE802_11::IEEE802_11(const IEEE802_11 &other) : PDU(other) { +Tins::Dot11::Dot11(const Dot11 &other) : PDU(other) { copy_80211_fields(&other); } -Tins::IEEE802_11::~IEEE802_11() { +Tins::Dot11::~Dot11() { while(_options.size()) { delete[] _options.front().value; _options.pop_front(); } } -Tins::IEEE802_11 &Tins::IEEE802_11::operator= (const IEEE802_11 &other) { +Tins::Dot11 &Tins::Dot11::operator= (const Dot11 &other) { copy_80211_fields(&other); copy_inner_pdu(other); return *this; } -void Tins::IEEE802_11::parse_tagged_parameters(const uint8_t *buffer, uint32_t total_sz) { +void Tins::Dot11::parse_tagged_parameters(const uint8_t *buffer, uint32_t total_sz) { uint8_t opcode, length; while(total_sz >= 2) { opcode = buffer[0]; @@ -116,110 +116,110 @@ void Tins::IEEE802_11::parse_tagged_parameters(const uint8_t *buffer, uint32_t t } } -Tins::IEEE802_11::IEEE802_11_Option::IEEE802_11_Option(uint8_t opt, uint8_t len, const uint8_t *val) : option(opt), length(len) { +Tins::Dot11::Dot11_Option::Dot11_Option(uint8_t opt, uint8_t len, const uint8_t *val) : option(opt), length(len) { value = new uint8_t[len]; std::memcpy(value, val, len); } -void Tins::IEEE802_11::add_tagged_option(TaggedOption opt, uint8_t len, const uint8_t *val) { +void Tins::Dot11::add_tagged_option(TaggedOption opt, uint8_t len, const uint8_t *val) { uint32_t opt_size = len + (sizeof(uint8_t) << 1); - _options.push_back(IEEE802_11_Option((uint8_t)opt, len, val)); + _options.push_back(Dot11_Option((uint8_t)opt, len, val)); _options_size += opt_size; } -const Tins::IEEE802_11::IEEE802_11_Option *Tins::IEEE802_11::lookup_option(TaggedOption opt) const { - for(std::list::const_iterator it = _options.begin(); it != _options.end(); ++it) +const Tins::Dot11::Dot11_Option *Tins::Dot11::lookup_option(TaggedOption opt) const { + for(std::list::const_iterator it = _options.begin(); it != _options.end(); ++it) if(it->option == (uint8_t)opt) return &(*it); return 0; } -void Tins::IEEE802_11::protocol(uint8_t new_proto) { +void Tins::Dot11::protocol(uint8_t new_proto) { this->_header.control.protocol = new_proto; } -void Tins::IEEE802_11::type(uint8_t new_type) { +void Tins::Dot11::type(uint8_t new_type) { this->_header.control.type = new_type; } -void Tins::IEEE802_11::subtype(uint8_t new_subtype) { +void Tins::Dot11::subtype(uint8_t new_subtype) { this->_header.control.subtype = new_subtype; } -void Tins::IEEE802_11::to_ds(bool new_value) { +void Tins::Dot11::to_ds(bool new_value) { this->_header.control.to_ds = (new_value)? 1 : 0; } -void Tins::IEEE802_11::from_ds(bool new_value) { +void Tins::Dot11::from_ds(bool new_value) { this->_header.control.from_ds = (new_value)? 1 : 0; } -void Tins::IEEE802_11::more_frag(bool new_value) { +void Tins::Dot11::more_frag(bool new_value) { this->_header.control.more_frag = (new_value)? 1 : 0; } -void Tins::IEEE802_11::retry(bool new_value) { +void Tins::Dot11::retry(bool new_value) { this->_header.control.retry = (new_value)? 1 : 0; } -void Tins::IEEE802_11::power_mgmt(bool new_value) { +void Tins::Dot11::power_mgmt(bool new_value) { this->_header.control.power_mgmt = (new_value)? 1 : 0; } -void Tins::IEEE802_11::wep(bool new_value) { +void Tins::Dot11::wep(bool new_value) { this->_header.control.wep = (new_value)? 1 : 0; } -void Tins::IEEE802_11::order(bool new_value) { +void Tins::Dot11::order(bool new_value) { this->_header.control.order = (new_value)? 1 : 0; } -void Tins::IEEE802_11::duration_id(uint16_t new_duration_id) { +void Tins::Dot11::duration_id(uint16_t new_duration_id) { this->_header.duration_id = Utils::net_to_host_s(new_duration_id); } -void Tins::IEEE802_11::addr1(const uint8_t* new_addr1) { +void Tins::Dot11::addr1(const uint8_t* new_addr1) { memcpy(this->_header.addr1, new_addr1, 6); } -void Tins::IEEE802_11::addr2(const uint8_t* new_addr2) { +void Tins::Dot11::addr2(const uint8_t* new_addr2) { memcpy(this->_header.addr2, new_addr2, 6); } -void Tins::IEEE802_11::addr3(const uint8_t* new_addr3) { +void Tins::Dot11::addr3(const uint8_t* new_addr3) { memcpy(this->_header.addr3, new_addr3, 6); } -void Tins::IEEE802_11::frag_num(uint8_t new_frag_num) { +void Tins::Dot11::frag_num(uint8_t new_frag_num) { this->_header.seq_control.frag_number = new_frag_num; } -void Tins::IEEE802_11::seq_num(uint16_t new_seq_num) { +void Tins::Dot11::seq_num(uint16_t new_seq_num) { this->_header.seq_control.seq_number = Utils::net_to_host_s(new_seq_num); } -void Tins::IEEE802_11::addr4(const uint8_t* new_addr4) { +void Tins::Dot11::addr4(const uint8_t* new_addr4) { memcpy(this->_addr4, new_addr4, 6); } -void Tins::IEEE802_11::iface(uint32_t new_iface_index) { +void Tins::Dot11::iface(uint32_t new_iface_index) { this->_iface_index = new_iface_index; } -void Tins::IEEE802_11::iface(const std::string& new_iface) throw (std::runtime_error) { +void Tins::Dot11::iface(const std::string& new_iface) throw (std::runtime_error) { if (!Tins::Utils::interface_id(new_iface, this->_iface_index)) { throw std::runtime_error("Invalid interface name!"); } } -uint32_t Tins::IEEE802_11::header_size() const { +uint32_t Tins::Dot11::header_size() const { uint32_t sz = sizeof(ieee80211_header) + _options_size; if (this->to_ds() && this->from_ds()) sz += 6; return sz; } -bool Tins::IEEE802_11::send(PacketSender* sender) { +bool Tins::Dot11::send(PacketSender* sender) { struct sockaddr_ll addr; memset(&addr, 0, sizeof(struct sockaddr_ll)); @@ -233,7 +233,7 @@ bool Tins::IEEE802_11::send(PacketSender* sender) { return sender->send_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr)); } -void Tins::IEEE802_11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) { +void Tins::Dot11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) { uint32_t my_sz = header_size(); assert(total_sz >= my_sz); memcpy(buffer, &this->_header, sizeof(ieee80211_header)); @@ -247,7 +247,7 @@ void Tins::IEEE802_11::write_serialization(uint8_t *buffer, uint32_t total_sz, c uint32_t child_len = write_fixed_parameters(buffer, total_sz - sizeof(ieee80211_header) - _options_size); buffer += child_len; assert(total_sz > child_len + _options_size); - for(std::list::const_iterator it = _options.begin(); it != _options.end(); ++it) { + for(std::list::const_iterator it = _options.begin(); it != _options.end(); ++it) { *(buffer++) = it->option; *(buffer++) = it->length; std::memcpy(buffer, it->value, it->length); @@ -255,7 +255,7 @@ 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) { +Tins::PDU *Tins::Dot11::from_bytes(const uint8_t *buffer, uint32_t total_sz) { // 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."); @@ -264,49 +264,49 @@ Tins::PDU *Tins::IEEE802_11::from_bytes(const uint8_t *buffer, uint32_t total_sz 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); + ret = new Dot11Beacon(buffer, total_sz); } else - ret = new IEEE802_11(buffer, total_sz); + ret = new Dot11(buffer, total_sz); return ret; } -void Tins::IEEE802_11::copy_80211_fields(const IEEE802_11 *other) { +void Tins::Dot11::copy_80211_fields(const Dot11 *other) { std::memcpy(&_header, &other->_header, sizeof(_header)); std::memcpy(_addr4, other->_addr4, sizeof(_header)); _iface_index = other->_iface_index; _options_size = other->_options_size; - for(std::list::const_iterator it = other->_options.begin(); it != other->_options.end(); ++it) - _options.push_back(IEEE802_11_Option(it->option, it->length, it->value)); + for(std::list::const_iterator it = other->_options.begin(); it != other->_options.end(); ++it) + _options.push_back(Dot11_Option(it->option, it->length, it->value)); } /* - * ManagementFrame + * Dot11ManagementFrame */ -Tins::ManagementFrame::ManagementFrame(const uint8_t *buffer, uint32_t total_sz) : IEEE802_11(buffer, total_sz) { +Tins::Dot11ManagementFrame::Dot11ManagementFrame(const uint8_t *buffer, uint32_t total_sz) : Dot11(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) { - this->type(IEEE802_11::MANAGEMENT); +Tins::Dot11ManagementFrame::Dot11ManagementFrame(const uint8_t *dst_hw_addr, const uint8_t *src_hw_addr) : Dot11(dst_hw_addr, src_hw_addr) { + this->type(Dot11::MANAGEMENT); } -Tins::ManagementFrame::ManagementFrame(const std::string &iface, +Tins::Dot11ManagementFrame::Dot11ManagementFrame(const std::string &iface, const uint8_t *dst_hw_addr, - const uint8_t *src_hw_addr) throw (std::runtime_error) : IEEE802_11(iface, dst_hw_addr, src_hw_addr) { - this->type(IEEE802_11::MANAGEMENT); + const uint8_t *src_hw_addr) throw (std::runtime_error) : Dot11(iface, dst_hw_addr, src_hw_addr) { + this->type(Dot11::MANAGEMENT); } -Tins::ManagementFrame::ManagementFrame(const ManagementFrame &other) : IEEE802_11(other) { +Tins::Dot11ManagementFrame::Dot11ManagementFrame(const Dot11ManagementFrame &other) : Dot11(other) { } -void Tins::ManagementFrame::ssid(const std::string &new_ssid) { - add_tagged_option(IEEE802_11::SSID, new_ssid.size(), (const uint8_t*)new_ssid.c_str()); +void Tins::Dot11ManagementFrame::ssid(const std::string &new_ssid) { + add_tagged_option(Dot11::SSID, new_ssid.size(), (const uint8_t*)new_ssid.c_str()); } -void Tins::ManagementFrame::rates(const std::list &new_rates) { +void Tins::Dot11ManagementFrame::rates(const std::list &new_rates) { uint8_t *buffer = new uint8_t[new_rates.size()], *ptr = buffer; for(std::list::const_iterator it = new_rates.begin(); it != new_rates.end(); ++it) { uint8_t result = 0x80, left = *it / 0.5; @@ -318,18 +318,18 @@ void Tins::ManagementFrame::rates(const std::list &new_rates) { delete[] buffer; } -void Tins::ManagementFrame::channel(uint8_t new_channel) { +void Tins::Dot11ManagementFrame::channel(uint8_t new_channel) { add_tagged_option(DS_SET, 1, &new_channel); } -void Tins::ManagementFrame::rsn_information(const RSNInformation& info) { +void Tins::Dot11ManagementFrame::rsn_information(const RSNInformation& info) { uint32_t size; uint8_t *buffer = info.serialize(size); add_tagged_option(RSN, size, buffer); delete[] buffer; } -void Tins::ManagementFrame::supported_rates(const std::list &new_rates) { +void Tins::Dot11ManagementFrame::supported_rates(const std::list &new_rates) { uint8_t *buffer = new uint8_t[new_rates.size()], *ptr = buffer; for(std::list::const_iterator it = new_rates.begin(); it != new_rates.end(); ++it) { uint8_t result = 0x80, left = *it / 0.5; @@ -341,7 +341,7 @@ void Tins::ManagementFrame::supported_rates(const std::list &new_rates) { delete[] buffer; } -void Tins::ManagementFrame::extended_supported_rates(const std::list &new_rates) { +void Tins::Dot11ManagementFrame::extended_supported_rates(const std::list &new_rates) { uint8_t *buffer = new uint8_t[new_rates.size()], *ptr = buffer; for(std::list::const_iterator it = new_rates.begin(); it != new_rates.end(); ++it) { uint8_t result = 0x80, left = *it / 0.5; @@ -353,18 +353,18 @@ void Tins::ManagementFrame::extended_supported_rates(const std::list &new delete[] buffer; } -void Tins::ManagementFrame::qos_capabilities(uint8_t new_qos_capabilities) { +void Tins::Dot11ManagementFrame::qos_capabilities(uint8_t new_qos_capabilities) { add_tagged_option(QOS_CAPABILITY, 1, &new_qos_capabilities); } -void Tins::ManagementFrame::power_capabilities(uint8_t min_power, uint8_t max_power) { +void Tins::Dot11ManagementFrame::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::ManagementFrame::supported_channels(const std::list > &new_channels) { +void Tins::Dot11ManagementFrame::supported_channels(const std::list > &new_channels) { uint8_t* buffer = new uint8_t[new_channels.size() * 2]; uint8_t* ptr = buffer; for(std::list >::const_iterator it = new_channels.begin(); it != new_channels.end(); ++it) { @@ -375,7 +375,7 @@ void Tins::ManagementFrame::supported_channels(const std::listsubtype(IEEE802_11::BEACON); +Tins::Dot11Beacon::Dot11Beacon(const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr) : Dot11ManagementFrame() { + this->subtype(Dot11::BEACON); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Beacon::IEEE802_11_Beacon(const std::string& iface, +Tins::Dot11Beacon::Dot11Beacon(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::BEACON); + const uint8_t* src_hw_addr) throw (std::runtime_error) : Dot11ManagementFrame(iface, dst_hw_addr, src_hw_addr){ + this->subtype(Dot11::BEACON); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Beacon::IEEE802_11_Beacon(const uint8_t *buffer, uint32_t total_sz) : ManagementFrame(buffer, total_sz) { +Tins::Dot11Beacon::Dot11Beacon(const uint8_t *buffer, uint32_t total_sz) : Dot11ManagementFrame(buffer, total_sz) { buffer += sizeof(ieee80211_header); total_sz -= sizeof(ieee80211_header); if(total_sz < sizeof(_body)) @@ -414,52 +414,52 @@ Tins::IEEE802_11_Beacon::IEEE802_11_Beacon(const uint8_t *buffer, uint32_t total parse_tagged_parameters(buffer, total_sz); } -Tins::IEEE802_11_Beacon::IEEE802_11_Beacon(const IEEE802_11_Beacon &other) : ManagementFrame(other) { +Tins::Dot11Beacon::Dot11Beacon(const Dot11Beacon &other) : Dot11ManagementFrame(other) { } -Tins::IEEE802_11_Beacon &Tins::IEEE802_11_Beacon::operator= (const IEEE802_11_Beacon &other) { +Tins::Dot11Beacon &Tins::Dot11Beacon::operator= (const Dot11Beacon &other) { copy_fields(&other); copy_inner_pdu(other); return *this; } -void Tins::IEEE802_11_Beacon::copy_fields(const IEEE802_11_Beacon *other) { +void Tins::Dot11Beacon::copy_fields(const Dot11Beacon *other) { copy_80211_fields(other); std::memcpy(&_body, &other->_body, sizeof(_body)); } -void Tins::IEEE802_11_Beacon::timestamp(uint64_t new_timestamp) { +void Tins::Dot11Beacon::timestamp(uint64_t new_timestamp) { this->_body.timestamp = new_timestamp; } -void Tins::IEEE802_11_Beacon::interval(uint16_t new_interval) { +void Tins::Dot11Beacon::interval(uint16_t new_interval) { this->_body.interval = Utils::net_to_host_s(new_interval); } -void Tins::IEEE802_11_Beacon::essid(const std::string &new_essid) { - ManagementFrame::ssid(new_essid); +void Tins::Dot11Beacon::essid(const std::string &new_essid) { + Dot11ManagementFrame::ssid(new_essid); } -void Tins::IEEE802_11_Beacon::rates(const std::list &new_rates) { - ManagementFrame::rates(new_rates); +void Tins::Dot11Beacon::rates(const std::list &new_rates) { + Dot11ManagementFrame::rates(new_rates); } -void Tins::IEEE802_11_Beacon::channel(uint8_t new_channel) { - ManagementFrame::channel(new_channel); +void Tins::Dot11Beacon::channel(uint8_t new_channel) { + Dot11ManagementFrame::channel(new_channel); } -void Tins::IEEE802_11_Beacon::rsn_information(const RSNInformation& info) { - ManagementFrame::rsn_information(info); +void Tins::Dot11Beacon::rsn_information(const RSNInformation& info) { + Dot11ManagementFrame::rsn_information(info); } -string Tins::IEEE802_11_Beacon::essid() const { - const IEEE802_11::IEEE802_11_Option *option = lookup_option(SSID); +string Tins::Dot11Beacon::essid() const { + const Dot11::Dot11_Option *option = lookup_option(SSID); return (option) ? string((const char*)option->value, option->length) : 0; } -bool Tins::IEEE802_11_Beacon::rsn_information(RSNInformation *rsn) { - const IEEE802_11::IEEE802_11_Option *option = lookup_option(RSN); +bool Tins::Dot11Beacon::rsn_information(RSNInformation *rsn) { + const Dot11::Dot11_Option *option = lookup_option(RSN); if(!option || option->length < (sizeof(uint16_t) << 1) + sizeof(uint32_t)) return false; const uint8_t *buffer = option->value; @@ -499,11 +499,11 @@ bool Tins::IEEE802_11_Beacon::rsn_information(RSNInformation *rsn) { return true; } -uint32_t Tins::IEEE802_11_Beacon::header_size() const { - return IEEE802_11::header_size() + sizeof(BeaconBody); +uint32_t Tins::Dot11Beacon::header_size() const { + return Dot11::header_size() + sizeof(BeaconBody); } -uint32_t Tins::IEEE802_11_Beacon::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { +uint32_t Tins::Dot11Beacon::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { uint32_t sz = sizeof(BeaconBody); assert(sz <= total_sz); memcpy(buffer, &this->_body, sz); @@ -512,42 +512,42 @@ uint32_t Tins::IEEE802_11_Beacon::write_fixed_parameters(uint8_t *buffer, uint32 /* 802.11 diassoc */ -Tins::IEEE802_11_Disassoc::IEEE802_11_Disassoc() : ManagementFrame() { - this->subtype(IEEE802_11::DISASSOC); +Tins::Dot11Disassoc::Dot11Disassoc() : Dot11ManagementFrame() { + this->subtype(Dot11::DISASSOC); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Disassoc::IEEE802_11_Disassoc(const std::string& iface, +Tins::Dot11Disassoc::Dot11Disassoc(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::DISASSOC); + const uint8_t* src_hw_addr) throw (std::runtime_error) : Dot11ManagementFrame(iface, dst_hw_addr, src_hw_addr){ + this->subtype(Dot11::DISASSOC); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Disassoc::IEEE802_11_Disassoc(const IEEE802_11_Disassoc &other) : ManagementFrame(other) { +Tins::Dot11Disassoc::Dot11Disassoc(const Dot11Disassoc &other) : Dot11ManagementFrame(other) { copy_fields(&other); } -Tins::IEEE802_11_Disassoc &Tins::IEEE802_11_Disassoc::operator= (const IEEE802_11_Disassoc &other) { +Tins::Dot11Disassoc &Tins::Dot11Disassoc::operator= (const Dot11Disassoc &other) { copy_inner_pdu(other); copy_fields(&other); return *this; } -void Tins::IEEE802_11_Disassoc::copy_fields(const IEEE802_11_Disassoc *other) { +void Tins::Dot11Disassoc::copy_fields(const Dot11Disassoc *other) { copy_80211_fields(other); std::memcpy(&_body, &other->_body, sizeof(_body)); } -void Tins::IEEE802_11_Disassoc::reason_code(uint16_t new_reason_code) { +void Tins::Dot11Disassoc::reason_code(uint16_t new_reason_code) { this->_body.reason_code = new_reason_code; } -uint32_t Tins::IEEE802_11_Disassoc::header_size() const { - return IEEE802_11::header_size() + sizeof(DisassocBody); +uint32_t Tins::Dot11Disassoc::header_size() const { + return Dot11::header_size() + sizeof(DisassocBody); } -uint32_t Tins::IEEE802_11_Disassoc::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { +uint32_t Tins::Dot11Disassoc::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { uint32_t sz = sizeof(DisassocBody); assert(sz <= total_sz); memcpy(buffer, &this->_body, sz); @@ -617,19 +617,19 @@ Tins::RSNInformation Tins::RSNInformation::wpa2_psk() { /* Assoc request. */ -Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request() : ManagementFrame() { - this->subtype(IEEE802_11::ASSOC_REQ); +Tins::Dot11AssocRequest::Dot11AssocRequest() : Dot11ManagementFrame() { + this->subtype(Dot11::ASSOC_REQ); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request(const std::string& iface, +Tins::Dot11AssocRequest::Dot11AssocRequest(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); + const uint8_t* src_hw_addr) throw (std::runtime_error) : Dot11ManagementFrame(iface, dst_hw_addr, src_hw_addr){ + this->subtype(Dot11::ASSOC_REQ); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request(const uint8_t *buffer, uint32_t total_sz) : ManagementFrame(buffer, total_sz) { +Tins::Dot11AssocRequest::Dot11AssocRequest(const uint8_t *buffer, uint32_t total_sz) : Dot11ManagementFrame(buffer, total_sz) { buffer += sizeof(ieee80211_header); total_sz -= sizeof(ieee80211_header); if(total_sz < sizeof(_body)) @@ -640,58 +640,58 @@ Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request(const uint8_t *buffer, parse_tagged_parameters(buffer, total_sz); } -Tins::IEEE802_11_Assoc_Request::IEEE802_11_Assoc_Request(const IEEE802_11_Assoc_Request &other) : ManagementFrame(other) { +Tins::Dot11AssocRequest::Dot11AssocRequest(const Dot11AssocRequest &other) : Dot11ManagementFrame(other) { copy_fields(&other); } -Tins::IEEE802_11_Assoc_Request &Tins::IEEE802_11_Assoc_Request::operator= (const IEEE802_11_Assoc_Request &other) { +Tins::Dot11AssocRequest &Tins::Dot11AssocRequest::operator= (const Dot11AssocRequest &other) { copy_inner_pdu(other); copy_fields(&other); return *this; } -void Tins::IEEE802_11_Assoc_Request::copy_fields(const IEEE802_11_Assoc_Request *other) { +void Tins::Dot11AssocRequest::copy_fields(const Dot11AssocRequest *other) { copy_80211_fields(other); std::memcpy(&_body, &other->_body, sizeof(_body)); } -void Tins::IEEE802_11_Assoc_Request::listen_interval(uint16_t new_listen_interval) { +void Tins::Dot11AssocRequest::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) { - ManagementFrame::ssid(new_ssid); +void Tins::Dot11AssocRequest::ssid(const std::string &new_ssid) { + Dot11ManagementFrame::ssid(new_ssid); } -void Tins::IEEE802_11_Assoc_Request::supported_rates(const std::list &new_rates) { - ManagementFrame::supported_rates(new_rates); +void Tins::Dot11AssocRequest::supported_rates(const std::list &new_rates) { + Dot11ManagementFrame::supported_rates(new_rates); } -void Tins::IEEE802_11_Assoc_Request::extended_supported_rates(const std::list &new_rates) { - ManagementFrame::extended_supported_rates(new_rates); +void Tins::Dot11AssocRequest::extended_supported_rates(const std::list &new_rates) { + Dot11ManagementFrame::extended_supported_rates(new_rates); } -void Tins::IEEE802_11_Assoc_Request::power_capabilities(uint8_t min_power, uint8_t max_power) { - ManagementFrame::power_capabilities(min_power, max_power); +void Tins::Dot11AssocRequest::power_capabilities(uint8_t min_power, uint8_t max_power) { + Dot11ManagementFrame::power_capabilities(min_power, max_power); } -void Tins::IEEE802_11_Assoc_Request::supported_channels(const std::list > &new_channels) { - ManagementFrame::supported_channels(new_channels); +void Tins::Dot11AssocRequest::supported_channels(const std::list > &new_channels) { + Dot11ManagementFrame::supported_channels(new_channels); } -void Tins::IEEE802_11_Assoc_Request::rsn_information(const RSNInformation& info) { - ManagementFrame::rsn_information(info); +void Tins::Dot11AssocRequest::rsn_information(const RSNInformation& info) { + Dot11ManagementFrame::rsn_information(info); } -void Tins::IEEE802_11_Assoc_Request::qos_capabilities(uint8_t new_qos_capabilities) { - ManagementFrame::qos_capabilities(new_qos_capabilities); +void Tins::Dot11AssocRequest::qos_capabilities(uint8_t new_qos_capabilities) { + Dot11ManagementFrame::qos_capabilities(new_qos_capabilities); } -uint32_t Tins::IEEE802_11_Assoc_Request::header_size() const { - return IEEE802_11::header_size() + sizeof(AssocReqBody); +uint32_t Tins::Dot11AssocRequest::header_size() const { + return Dot11::header_size() + sizeof(AssocReqBody); } -uint32_t Tins::IEEE802_11_Assoc_Request::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { +uint32_t Tins::Dot11AssocRequest::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { uint32_t sz = sizeof(AssocReqBody); assert(sz <= total_sz); memcpy(buffer, &this->_body, sz); @@ -700,19 +700,19 @@ uint32_t Tins::IEEE802_11_Assoc_Request::write_fixed_parameters(uint8_t *buffer, /* Assoc response. */ -Tins::IEEE802_11_Assoc_Response::IEEE802_11_Assoc_Response() : ManagementFrame() { - this->subtype(IEEE802_11::ASSOC_RESP); +Tins::Dot11AssocResponse::Dot11AssocResponse() : Dot11ManagementFrame() { + this->subtype(Dot11::ASSOC_RESP); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Assoc_Response::IEEE802_11_Assoc_Response(const std::string& iface, +Tins::Dot11AssocResponse::Dot11AssocResponse(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_RESP); + const uint8_t* src_hw_addr) throw (std::runtime_error) : Dot11ManagementFrame(iface, dst_hw_addr, src_hw_addr) { + this->subtype(Dot11::ASSOC_RESP); memset(&_body, 0, sizeof(_body)); } -Tins::IEEE802_11_Assoc_Response::IEEE802_11_Assoc_Response(const uint8_t *buffer, uint32_t total_sz) : ManagementFrame(buffer, total_sz) { +Tins::Dot11AssocResponse::Dot11AssocResponse(const uint8_t *buffer, uint32_t total_sz) : Dot11ManagementFrame(buffer, total_sz) { buffer += sizeof(ieee80211_header); total_sz -= sizeof(ieee80211_header); if(total_sz < sizeof(_body)) @@ -723,46 +723,46 @@ Tins::IEEE802_11_Assoc_Response::IEEE802_11_Assoc_Response(const uint8_t *buffer parse_tagged_parameters(buffer, total_sz); } -Tins::IEEE802_11_Assoc_Response::IEEE802_11_Assoc_Response(const IEEE802_11_Assoc_Response &other) : ManagementFrame(other) { +Tins::Dot11AssocResponse::Dot11AssocResponse(const Dot11AssocResponse &other) : Dot11ManagementFrame(other) { copy_fields(&other); } -Tins::IEEE802_11_Assoc_Response &Tins::IEEE802_11_Assoc_Response::operator= (const IEEE802_11_Assoc_Response &other) { +Tins::Dot11AssocResponse &Tins::Dot11AssocResponse::operator= (const Dot11AssocResponse &other) { copy_inner_pdu(other); copy_fields(&other); return *this; } -void Tins::IEEE802_11_Assoc_Response::copy_fields(const IEEE802_11_Assoc_Response *other) { +void Tins::Dot11AssocResponse::copy_fields(const Dot11AssocResponse *other) { copy_80211_fields(other); std::memcpy(&_body, &other->_body, sizeof(_body)); } -void Tins::IEEE802_11_Assoc_Response::status_code(uint16_t new_status_code) { +void Tins::Dot11AssocResponse::status_code(uint16_t new_status_code) { this->_body.status_code = new_status_code; } -void Tins::IEEE802_11_Assoc_Response::aid(uint16_t new_aid) { +void Tins::Dot11AssocResponse::aid(uint16_t new_aid) { this->_body.aid = new_aid; } -void Tins::IEEE802_11_Assoc_Response::supported_rates(const std::list &new_rates) { - ManagementFrame::supported_rates(new_rates); +void Tins::Dot11AssocResponse::supported_rates(const std::list &new_rates) { + Dot11ManagementFrame::supported_rates(new_rates); } -void Tins::IEEE802_11_Assoc_Response::extended_supported_rates(const std::list &new_rates) { - ManagementFrame::extended_supported_rates(new_rates); +void Tins::Dot11AssocResponse::extended_supported_rates(const std::list &new_rates) { + Dot11ManagementFrame::extended_supported_rates(new_rates); } -void Tins::IEEE802_11_Assoc_Response::edca_parameter_set(uint32_t ac_be, uint32_t ac_bk, uint32_t ac_vi, uint32_t ac_vo) { - ManagementFrame::edca_parameter_set(ac_be, ac_bk, ac_vi, ac_vo); +void Tins::Dot11AssocResponse::edca_parameter_set(uint32_t ac_be, uint32_t ac_bk, uint32_t ac_vi, uint32_t ac_vo) { + Dot11ManagementFrame::edca_parameter_set(ac_be, ac_bk, ac_vi, ac_vo); } -uint32_t Tins::IEEE802_11_Assoc_Response::header_size() const { - return IEEE802_11::header_size() + sizeof(AssocRespBody); +uint32_t Tins::Dot11AssocResponse::header_size() const { + return Dot11::header_size() + sizeof(AssocRespBody); } -uint32_t Tins::IEEE802_11_Assoc_Response::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { +uint32_t Tins::Dot11AssocResponse::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { uint32_t sz = sizeof(AssocRespBody); assert(sz <= total_sz); memcpy(buffer, &this->_body, sz); @@ -771,25 +771,25 @@ uint32_t Tins::IEEE802_11_Assoc_Response::write_fixed_parameters(uint8_t *buffer /* QoS data. */ -Tins::IEEE802_11_QoS_Data::IEEE802_11_QoS_Data(const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : IEEE802_11(dst_hw_addr, src_hw_addr, child) { - this->type(IEEE802_11::DATA); - this->subtype(IEEE802_11::QOS_DATA_DATA); +Tins::Dot11QoSData::Dot11QoSData(const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : Dot11(dst_hw_addr, src_hw_addr, child) { + this->type(Dot11::DATA); + this->subtype(Dot11::QOS_DATA_DATA); this->_qos_control = 0; } -Tins::IEEE802_11_QoS_Data::IEEE802_11_QoS_Data(const std::string& iface, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) throw (std::runtime_error) : IEEE802_11(iface, dst_hw_addr, src_hw_addr, child) { - this->type(IEEE802_11::DATA); - this->subtype(IEEE802_11::QOS_DATA_DATA); +Tins::Dot11QoSData::Dot11QoSData(const std::string& iface, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) throw (std::runtime_error) : Dot11(iface, dst_hw_addr, src_hw_addr, child) { + this->type(Dot11::DATA); + this->subtype(Dot11::QOS_DATA_DATA); this->_qos_control = 0; } -Tins::IEEE802_11_QoS_Data::IEEE802_11_QoS_Data(uint32_t iface_index, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : IEEE802_11(iface_index, dst_hw_addr, src_hw_addr, child) { - this->type(IEEE802_11::DATA); - this->subtype(IEEE802_11::QOS_DATA_DATA); +Tins::Dot11QoSData::Dot11QoSData(uint32_t iface_index, const uint8_t* dst_hw_addr, const uint8_t* src_hw_addr, PDU* child) : Dot11(iface_index, dst_hw_addr, src_hw_addr, child) { + this->type(Dot11::DATA); + this->subtype(Dot11::QOS_DATA_DATA); this->_qos_control = 0; } -Tins::IEEE802_11_QoS_Data::IEEE802_11_QoS_Data(const uint8_t *buffer, uint32_t total_sz) : IEEE802_11(buffer, total_sz) { +Tins::Dot11QoSData::Dot11QoSData(const uint8_t *buffer, uint32_t total_sz) : Dot11(buffer, total_sz) { buffer += sizeof(ieee80211_header); total_sz -= sizeof(ieee80211_header); assert(total_sz >= sizeof(this->_qos_control)); @@ -800,30 +800,30 @@ Tins::IEEE802_11_QoS_Data::IEEE802_11_QoS_Data(const uint8_t *buffer, uint32_t t inner_pdu(new Tins::SNAP(buffer, total_sz)); } -Tins::IEEE802_11_QoS_Data::IEEE802_11_QoS_Data(const IEEE802_11_QoS_Data &other) : IEEE802_11(other) { +Tins::Dot11QoSData::Dot11QoSData(const Dot11QoSData &other) : Dot11(other) { copy_fields(&other); } -Tins::IEEE802_11_QoS_Data &Tins::IEEE802_11_QoS_Data::operator= (const IEEE802_11_QoS_Data &other) { +Tins::Dot11QoSData &Tins::Dot11QoSData::operator= (const Dot11QoSData &other) { copy_inner_pdu(other); copy_fields(&other); return *this; } -void Tins::IEEE802_11_QoS_Data::copy_fields(const IEEE802_11_QoS_Data *other) { +void Tins::Dot11QoSData::copy_fields(const Dot11QoSData *other) { copy_80211_fields(other); _qos_control = other->_qos_control; } -void Tins::IEEE802_11_QoS_Data::qos_control(uint16_t new_qos_control) { +void Tins::Dot11QoSData::qos_control(uint16_t new_qos_control) { this->_qos_control = new_qos_control; } -uint32_t Tins::IEEE802_11_QoS_Data::header_size() const { - return IEEE802_11::header_size() + sizeof(this->_qos_control); +uint32_t Tins::Dot11QoSData::header_size() const { + return Dot11::header_size() + sizeof(this->_qos_control); } -uint32_t Tins::IEEE802_11_QoS_Data::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { +uint32_t Tins::Dot11QoSData::write_fixed_parameters(uint8_t *buffer, uint32_t total_sz) { uint32_t sz = sizeof(this->_qos_control); assert(sz <= total_sz); *(uint16_t*)buffer = this->_qos_control; diff --git a/src/eapol.cpp b/src/eapol.cpp index 6cc942d..5fbc801 100644 --- a/src/eapol.cpp +++ b/src/eapol.cpp @@ -23,7 +23,7 @@ #include #include #include "eapol.h" -#include "ieee802-11.h" +#include "dot11.h" Tins::EAPOL::EAPOL(uint8_t packet_type, EAPOLTYPE type) : PDU(0xff) { @@ -287,7 +287,7 @@ void Tins::RSNEAPOL::write_body(uint8_t *buffer, uint32_t total_sz) { buffer += sizeof(_header); if(_key) { if(_header.key_type && _key_size) { - *(buffer++) = IEEE802_11::RSN; + *(buffer++) = Dot11::RSN; *(buffer++) = _key_size; } std::memcpy(buffer, _key, _key_size); diff --git a/src/radiotap.cpp b/src/radiotap.cpp index e129a08..b18258e 100644 --- a/src/radiotap.cpp +++ b/src/radiotap.cpp @@ -26,7 +26,7 @@ #include #endif #include "radiotap.h" -#include "ieee802-11.h" +#include "dot11.h" #include "utils.h" @@ -108,7 +108,7 @@ Tins::RadioTap::RadioTap(const uint8_t *buffer, uint32_t total_sz) : PDU(0xff) { total_sz -= sizeof(_rx_flags); } if(total_sz) - inner_pdu(IEEE802_11::from_bytes(buffer, total_sz)); + inner_pdu(Dot11::from_bytes(buffer, total_sz)); } void Tins::RadioTap::version(uint8_t new_version) { @@ -196,7 +196,7 @@ bool Tins::RadioTap::send(PacketSender* sender) { addr.sll_halen = 6; addr.sll_ifindex = _iface_index; - Tins::IEEE802_11 *wlan = dynamic_cast(inner_pdu()); + Tins::Dot11 *wlan = dynamic_cast(inner_pdu()); if(wlan) memcpy(&(addr.sll_addr), wlan->addr1(), 6);