DhcpV6Layer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "TLVData.h"
 
 
namespace pcpp
{
    enum DhcpV6MessageType
    {
        DHCPV6_UNKNOWN_MSG_TYPE = 0,
        DHCPV6_SOLICIT = 1,
        DHCPV6_ADVERTISE = 2,
        DHCPV6_REQUEST = 3,
        DHCPV6_CONFIRM = 4,
        DHCPV6_RENEW = 5,
        DHCPV6_REBIND = 6,
        DHCPV6_REPLY = 7,
        DHCPV6_RELEASE = 8,
        DHCPV6_DECLINE = 9,
        DHCPV6_RECONFIGURE = 10,
        DHCPV6_INFORMATION_REQUEST = 11,
        DHCPV6_RELAY_FORWARD = 12,
        DHCPV6_RELAY_REPLY = 13
    };
 
    enum DhcpV6OptionType
    {
        DHCPV6_OPT_UNKNOWN = 0,
        DHCPV6_OPT_CLIENTID = 1,
        DHCPV6_OPT_SERVERID = 2,
        DHCPV6_OPT_IA_NA = 3,
        DHCPV6_OPT_IA_TA = 4,
        DHCPV6_OPT_IAADDR = 5,
        DHCPV6_OPT_ORO = 6,
        DHCPV6_OPT_PREFERENCE = 7,
        DHCPV6_OPT_ELAPSED_TIME = 8,
        DHCPV6_OPT_RELAY_MSG = 9,
        DHCPV6_OPT_AUTH = 11,
        DHCPV6_OPT_UNICAST = 12,
        DHCPV6_OPT_STATUS_CODE = 13,
        DHCPV6_OPT_RAPID_COMMIT = 14,
        DHCPV6_OPT_USER_CLASS = 15,
        DHCPV6_OPT_VENDOR_CLASS = 16,
        DHCPV6_OPT_VENDOR_OPTS = 17,
        DHCPV6_OPT_INTERFACE_ID = 18,
        DHCPV6_OPT_RECONF_MSG = 19,
        DHCPV6_OPT_RECONF_ACCEPT = 20,
        DHCPV6_OPT_SIP_SERVERS_D = 21,
        DHCPV6_OPT_SIP_SERVERS_A = 22,
        DHCPV6_OPT_DNS_SERVERS = 23,
        DHCPV6_OPT_DOMAIN_LIST = 24,
        DHCPV6_OPT_IA_PD = 25,
        DHCPV6_OPT_IAPREFIX = 26,
        DHCPV6_OPT_NIS_SERVERS = 27,
        DHCPV6_OPT_NISP_SERVERS = 28,
        DHCPV6_OPT_NIS_DOMAIN_NAME = 29,
        DHCPV6_OPT_NISP_DOMAIN_NAME = 30,
        DHCPV6_OPT_SNTP_SERVERS = 31,
        DHCPV6_OPT_INFORMATION_REFRESH_TIME = 32,
        DHCPV6_OPT_BCMCS_SERVER_D = 33,
        DHCPV6_OPT_BCMCS_SERVER_A = 34,
        DHCPV6_OPT_GEOCONF_CIVIC = 36,
        DHCPV6_OPT_REMOTE_ID = 37,
        DHCPV6_OPT_SUBSCRIBER_ID = 38,
        DHCPV6_OPT_CLIENT_FQDN = 39,
        DHCPV6_OPT_PANA_AGENT = 40,
        DHCPV6_OPT_NEW_POSIX_TIMEZONE = 41,
        DHCPV6_OPT_NEW_TZDB_TIMEZONE = 42,
        DHCPV6_OPT_ERO = 43,
        DHCPV6_OPT_LQ_QUERY = 44,
        DHCPV6_OPT_CLIENT_DATA = 45,
        DHCPV6_OPT_CLT_TIME = 46,
        DHCPV6_OPT_LQ_RELAY_DATA = 47,
        DHCPV6_OPT_LQ_CLIENT_LINK = 48,
        DHCPV6_OPT_MIP6_HNINF = 49,
        DHCPV6_OPT_MIP6_RELAY = 50,
        DHCPV6_OPT_V6_LOST = 51,
        DHCPV6_OPT_CAPWAP_AC_V6 = 52,
        DHCPV6_OPT_RELAY_ID = 53,
        DHCPV6_OPT_IPH6_ADDRESS_MOS = 54,
        DHCPV6_OPT_IPV6_FQDN_MOS = 55,
        DHCPV6_OPT_NTP_SERVER = 56,
        DHCPV6_OPT_BOOTFILE_URL = 59,
        DHCPV6_OPT_BOOTFILE_PARAM = 60,
        DHCPV6_OPT_CLIENT_ARCH_TYPE = 61,
        DHCPV6_OPT_NII = 62,
        DHCPV6_OPT_ERP_LOCAL_DOMAIN_NAME = 65,
        DHCPV6_OPT_RELAY_SUPPLIED_OPTIONS = 66,
        DHCPV6_OPT_VSS = 68,
        DHCPV6_OPT_CLIENT_LINKLAYER_ADDR = 79,
        DHCPV6_OPT_MUD_URL = 112
    };
 
    class DhcpV6Option : public TLVRecord<uint16_t, uint16_t>
    {
    public:
        explicit DhcpV6Option(uint8_t* optionRawData) : TLVRecord(optionRawData)
        {}
 
        ~DhcpV6Option() override = default;
 
        DhcpV6OptionType getType() const;
 
        std::string getValueAsHexString() const;
 
        // implement abstract methods
 
        size_t getTotalSize() const override;
        size_t getDataSize() const override;
    };
 
    class DhcpV6OptionBuilder : public TLVRecordBuilder
    {
    public:
        DhcpV6OptionBuilder(DhcpV6OptionType optionType, const std::string& optionValueAsHexStream)
            : TLVRecordBuilder(static_cast<uint16_t>(optionType), optionValueAsHexStream, true)
        {}
 
        DhcpV6OptionBuilder(DhcpV6OptionType optionType, const uint8_t* optionValue, uint8_t optionValueLen)
            : TLVRecordBuilder(static_cast<uint16_t>(optionType), optionValue, optionValueLen)
        {}
 
        DhcpV6Option build() const;
    };
 
    struct dhcpv6_header
    {
        uint8_t messageType;
        uint8_t transactionId1;
        uint8_t transactionId2;
        uint8_t transactionId3;
    };
    static_assert(sizeof(dhcpv6_header) == 4, "dhcpv6_header size is not 4 bytes");
 
    class DhcpV6Layer : public Layer
    {
    public:
        DhcpV6Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        DhcpV6Layer(DhcpV6MessageType messageType, uint32_t transactionId);
 
        DhcpV6MessageType getMessageType() const;
 
        std::string getMessageTypeAsString() const;
 
        void setMessageType(DhcpV6MessageType messageType);
 
        uint32_t getTransactionID() const;
 
        void setTransactionID(uint32_t transactionId) const;
 
        DhcpV6Option getFirstOptionData() const;
 
        DhcpV6Option getNextOptionData(DhcpV6Option dhcpv6Option) const;
 
        DhcpV6Option getOptionData(DhcpV6OptionType option) const;
 
        size_t getOptionCount() const;
 
        DhcpV6Option addOption(const DhcpV6OptionBuilder& optionBuilder);
 
        DhcpV6Option addOptionAfter(const DhcpV6OptionBuilder& optionBuilder, DhcpV6OptionType optionType);
 
        DhcpV6Option addOptionBefore(const DhcpV6OptionBuilder& optionBuilder, DhcpV6OptionType optionType);
 
        bool removeOption(DhcpV6OptionType optionType);
 
        bool removeAllOptions();
 
        static inline bool isDhcpV6Port(uint16_t port);
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        void computeCalculateFields() override
        {}
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelApplicationLayer;
        }
 
    private:
        uint8_t* getOptionsBasePtr() const
        {
            return m_Data + sizeof(dhcpv6_header);
        }
        dhcpv6_header* getDhcpHeader() const
        {
            return reinterpret_cast<dhcpv6_header*>(m_Data);
        }
        DhcpV6Option addOptionAt(const DhcpV6OptionBuilder& optionBuilder, int offset);
 
        TLVRecordReader<DhcpV6Option> m_OptionReader;
    };
 
    // implementation of inline methods
 
    bool DhcpV6Layer::isDhcpV6Port(uint16_t port)
    {
        return (port == 546) || (port == 547);
    }
 
    bool DhcpV6Layer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        return data && dataLen >= sizeof(dhcpv6_header);
    }
 
}  // namespace pcpp