dot11_control.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_CONTROL_H) && defined(TINS_HAVE_DOT11)

#define TINS_DOT11_DOT11_CONTROL_H

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

namespace Tins {
class TINS_API Dot11Control : public Dot11 {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_CONTROL;
    
    Dot11Control(const address_type& dst_addr = address_type());

    Dot11Control(const uint8_t* buffer, uint32_t total_sz);

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

class TINS_API Dot11ControlTA : public Dot11Control {
public:
    address_type target_addr() const {
        return taddr_;
    }

    void target_addr(const address_type& addr);
protected:
    Dot11ControlTA(const address_type& dst_addr = address_type(), 
                const address_type& target_addr = address_type());

    Dot11ControlTA(const uint8_t* buffer, uint32_t total_sz);

    uint32_t header_size() const;
protected:
    uint32_t controlta_size() const { 
        return static_cast<uint32_t>(taddr_.size() + sizeof(dot11_header)); 
    }

    void write_ext_header(Memory::OutputMemoryStream& stream);
private:

    address_type taddr_;
};

class TINS_API Dot11RTS : public Dot11ControlTA {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_RTS;

    Dot11RTS(const address_type& dst_addr = address_type(), 
             const address_type& target_addr = address_type());
                
    Dot11RTS(const uint8_t* buffer, uint32_t total_sz);

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

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

class TINS_API Dot11PSPoll : public Dot11ControlTA {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_PS_POLL;

    Dot11PSPoll(const address_type& dst_addr = address_type(), 
                const address_type& target_addr = address_type());

    Dot11PSPoll(const uint8_t* buffer, uint32_t total_sz);

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

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

class TINS_API Dot11CFEnd : public Dot11ControlTA {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_CF_END;

    Dot11CFEnd(const address_type& dst_addr = address_type(), 
               const address_type& target_addr = address_type());
                
    Dot11CFEnd(const uint8_t* buffer, uint32_t total_sz);

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

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

class TINS_API Dot11EndCFAck : public Dot11ControlTA {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_END_CF_ACK;

    Dot11EndCFAck(const address_type& dst_addr = address_type(), 
                  const address_type& target_addr = address_type());

    Dot11EndCFAck(const uint8_t* buffer, uint32_t total_sz);

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

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

class TINS_API Dot11Ack : public Dot11Control {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_ACK;

    Dot11Ack(const address_type& dst_addr = address_type());

    Dot11Ack(const uint8_t* buffer, uint32_t total_sz);

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

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

class TINS_API Dot11BlockAckRequest : public Dot11ControlTA {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_BLOCK_ACK_REQ;

    Dot11BlockAckRequest(const address_type& dst_addr = address_type(), 
                         const address_type& target_addr = address_type());

    Dot11BlockAckRequest(const uint8_t* buffer, uint32_t total_sz);

    /* Getter */

    small_uint<4> bar_control() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return bar_control_ & 0xf; 
        #else
        return (bar_control_ >> 8) & 0xf; 
        #endif
    }

    small_uint<12> start_sequence() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return (start_sequence_ >> 4) & 0xfff; 
        #else
        return (Endian::le_to_host<uint16_t>(start_sequence_) >> 4) & 0xfff; 
        #endif
    }
    
    small_uint<4> fragment_number() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return start_sequence_ & 0xf; 
        #else
        return (start_sequence_ >> 8) & 0xf; 
        #endif
    }
    
    uint32_t header_size() const;

    /* Setter */

    void bar_control(small_uint<4> bar);

    void start_sequence(small_uint<12> seq);
    
    void fragment_number(small_uint<4> frag);

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

    PDUType pdu_type() const {
        return pdu_flag;
    }

    bool matches_flag(PDUType flag) const {
        return flag == pdu_flag || Dot11Control::matches_flag(flag);
    }
protected:
    void write_ext_header(Memory::OutputMemoryStream& stream);
private:
    uint16_t bar_control_;
    uint16_t start_sequence_;
};

class TINS_API Dot11BlockAck : public Dot11ControlTA {
public:
    static const PDU::PDUType pdu_flag = PDU::DOT11_BLOCK_ACK;
    
    static const size_t bitmap_size = 8;

    Dot11BlockAck(const address_type& dst_addr = address_type(), 
                  const address_type& target_addr = address_type());

    Dot11BlockAck(const uint8_t* buffer, uint32_t total_sz);

    /* Getters */

    small_uint<4> bar_control() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return bar_control_ & 0xf; 
        #else
        return (bar_control_ >> 8) & 0xf; 
        #endif
    }

    small_uint<12> start_sequence() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return (start_sequence_ >> 4) & 0xfff; 
        #else
        return (Endian::le_to_host<uint16_t>(start_sequence_) >> 4) & 0xfff; 
        #endif
    }
    
    small_uint<4> fragment_number() const { 
        #if TINS_IS_LITTLE_ENDIAN
        return start_sequence_ & 0xf; 
        #else
        return (start_sequence_ >> 8) & 0xf; 
        #endif
    }
    
    uint32_t header_size() const;

    /* Setters */

    void bar_control(small_uint<4> bar);

    void start_sequence(small_uint<12> seq);
    
    void fragment_number(small_uint<4> frag);

    const uint8_t* bitmap() const {
        return bitmap_;
    }

    void bitmap(const uint8_t* bit);

    PDUType pdu_type() const {
        return pdu_flag;
    }

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

    Dot11BlockAck* clone() const {
        return new Dot11BlockAck(*this);
    }
private:
    void write_ext_header(Memory::OutputMemoryStream& stream);

    uint16_t bar_control_, start_sequence_;
    uint8_t bitmap_[bitmap_size];
};

} // namespace Tins

#endif // TINS_DOT11_DOT11_CONTROL_H