pdu.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.
 *
 */
 
#ifndef TINS_PDU_H
#define TINS_PDU_H
 
 
#include <stdint.h>
#include <vector>
#include <tins/macros.h>
#include <tins/cxxstd.h>
#include <tins/exceptions.h>
 
namespace Tins {
 
class PacketSender;
class NetworkInterface;
 
typedef std::vector<uint8_t> byte_array;
 
class TINS_API PDU {
public:
    typedef byte_array serialization_type;
 
    enum endian_type {
        BE,
        LE
    };
 
    enum PDUType {
        RAW,
        ETHERNET_II,
        IEEE802_3,
        DOT3 = IEEE802_3,
        RADIOTAP,
        DOT11,
        DOT11_ACK,
        DOT11_ASSOC_REQ,
        DOT11_ASSOC_RESP,
        DOT11_AUTH,
        DOT11_BEACON,
        DOT11_BLOCK_ACK,
        DOT11_BLOCK_ACK_REQ,
        DOT11_CF_END,
        DOT11_DATA,
        DOT11_CONTROL,
        DOT11_DEAUTH,
        DOT11_DIASSOC,
        DOT11_END_CF_ACK,
        DOT11_MANAGEMENT,
        DOT11_PROBE_REQ,
        DOT11_PROBE_RESP,
        DOT11_PS_POLL,
        DOT11_REASSOC_REQ,
        DOT11_REASSOC_RESP,
        DOT11_RTS,
        DOT11_QOS_DATA,
        LLC,
        SNAP,
        IP,
        ARP,
        TCP,
        UDP,
        ICMP,
        BOOTP,
        DHCP,
        EAPOL,
        RC4EAPOL,
        RSNEAPOL,
        DNS,
        LOOPBACK,
        IPv6,
        ICMPv6,
        SLL,
        DHCPv6,
        DOT1AD,
        DOT1Q,
        PPPOE,
        STP,
        PPI,
        IPSEC_AH,
        IPSEC_ESP,
        PKTAP,
        MPLS,
        DOT11_CONTROL_TA,
        VXLAN,
        RTP,
        UNKNOWN = 999,
        USER_DEFINED_PDU = 1000
    };
 
    static const endian_type endianness = BE;
 
    struct metadata {
        metadata();
 
        metadata(uint32_t header_size, PDUType current_type, PDUType next_type);
 
        uint32_t header_size;
 
        PDUType current_pdu_type;
 
        PDUType next_pdu_type;
    };
 
    PDU();
 
    #if TINS_IS_CXX11
        PDU(PDU &&rhs) TINS_NOEXCEPT
        : inner_pdu_(0), parent_pdu_(0) {
            std::swap(inner_pdu_, rhs.inner_pdu_);
            if (inner_pdu_) {
                inner_pdu_->parent_pdu(this);
            }
        }
 
        PDU& operator=(PDU &&rhs) TINS_NOEXCEPT {
            delete inner_pdu_;
            inner_pdu_ = 0;
            std::swap(inner_pdu_, rhs.inner_pdu_);
            if (inner_pdu_) {
                inner_pdu_->parent_pdu(this);
            }
            return* this;
        }
    #endif
 
    virtual ~PDU();
 
    virtual uint32_t header_size() const = 0;
 
    virtual uint32_t trailer_size() const {
        return 0;
    }
 
    uint32_t size() const;
 
    virtual uint32_t advertised_size() const;
 
    PDU* inner_pdu() const {
        return inner_pdu_;
    }
 
    PDU* parent_pdu() const {
        return parent_pdu_;
    }
 
    PDU* release_inner_pdu();
 
    void inner_pdu(PDU* next_pdu);
 
    void inner_pdu(const PDU& next_pdu);
 
    serialization_type serialize();
 
    template<typename T>
    T* find_pdu(PDUType type = T::pdu_flag) {
        PDU* pdu = this;
        while (pdu) {
            if (pdu->matches_flag(type)) {
                return static_cast<T*>(pdu);
            }
            pdu = pdu->inner_pdu();
        }
        return 0;
    }
 
    template<typename T>
    const T* find_pdu(PDUType type = T::pdu_flag) const {
        return const_cast<PDU*>(this)->find_pdu<T>(type);
    }
 
    template<typename T>
    T& rfind_pdu(PDUType type = T::pdu_flag) {
        T* ptr = find_pdu<T>(type);
        if (!ptr) {
            throw pdu_not_found();
        }
        return* ptr;
    }
 
    template<typename T>
    const T& rfind_pdu(PDUType type = T::pdu_flag) const {
        return const_cast<PDU*>(this)->rfind_pdu<T>(type);
    }
 
    virtual PDU* clone() const = 0;
 
    virtual void send(PacketSender& sender, const NetworkInterface& iface);
 
    virtual PDU* recv_response(PacketSender& sender, const NetworkInterface& iface);
 
    virtual bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
    virtual bool matches_flag(PDUType flag) const {
       return flag == pdu_type();
    }
 
    virtual PDUType pdu_type() const = 0;
protected:
    PDU(const PDU& other);
 
    PDU& operator=(const PDU& other);
 
    void copy_inner_pdu(const PDU& pdu);
 
    virtual void prepare_for_serialize();
 
    void serialize(uint8_t* buffer, uint32_t total_sz);
 
    virtual void write_serialization(uint8_t* buffer, uint32_t total_sz) = 0;
private:
    void parent_pdu(PDU* parent);
 
    PDU* inner_pdu_;
    PDU* parent_pdu_;
};
 
template<typename T>
T& operator/= (T& lop, const PDU& rop) {
    PDU* last = &lop;
    while (last->inner_pdu()) {
        last = last->inner_pdu();
    }
    last->inner_pdu(rop.clone());
    return lop;
}
 
template<typename T>
T operator/ (T lop, const PDU& rop) {
    lop /= rop;
    return lop;
}
 
template<typename T>
T* operator/= (T* lop, const PDU& rop) {
    *lop /= rop;
    return lop;
}
 
namespace Internals {
    template<typename T>
    struct remove_pointer {
        typedef T type;
    };
 
    template<typename T>
    struct remove_pointer<T*> {
        typedef T type;
    };
}
 
template<typename T, typename U>
T tins_cast(U* pdu) {
    typedef typename Internals::remove_pointer<T>::type TrueT;
    return pdu && (TrueT::pdu_flag == pdu->pdu_type()) ?
           static_cast<T>(pdu) : 0;
}
 
template<typename T, typename U>
T& tins_cast(U& pdu) {
    T* ptr = tins_cast<T*>(&pdu);
    if (!ptr) {
        throw bad_tins_cast();
    }
    return* ptr;
}
 
} // Tins
 
#endif // TINS_PDU_H