DhcpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_DHCP_LAYER
#define PACKETPP_DHCP_LAYER

#include "Layer.h"
#include "TLVData.h"
#include "IpAddress.h"
#include "MacAddress.h"
#include <string.h>

#ifndef PCPP_DEPRECATED
#if defined(__GNUC__) || defined(__clang__)
#define PCPP_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define PCPP_DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: DEPRECATED feature is not implemented for this compiler")
#define PCPP_DEPRECATED
#endif
#endif


namespace pcpp
{

    #pragma pack(push, 1)
    struct dhcp_header
    {
        uint8_t opCode;
        uint8_t hardwareType;
        uint8_t hardwareAddressLength;
        uint8_t hops;
        uint32_t transactionID;
        uint16_t secondsElapsed;
        uint16_t flags;
        uint32_t clientIpAddress;
        uint32_t yourIpAddress;
        uint32_t serverIpAddress;
        uint32_t gatewayIpAddress;
        uint8_t clientHardwareAddress[16];
        uint8_t serverName[64];
        uint8_t bootFilename[128];
        uint32_t magicNumber;
    };
    #pragma pack(pop)


    enum BootpOpCodes
    {
        DHCP_BOOTREQUEST = 1,
        DHCP_BOOTREPLY = 2
    };

    enum DhcpMessageType
    {
        DHCP_UNKNOWN_MSG_TYPE = 0,
        DHCP_DISCOVER         = 1,
        DHCP_OFFER            = 2,
        DHCP_REQUEST          = 3,
        DHCP_DECLINE          = 4,
        DHCP_ACK              = 5,
        DHCP_NAK              = 6,
        DHCP_RELEASE          = 7,
        DHCP_INFORM           = 8
    };

    enum DhcpOptionTypes
    {
        DHCPOPT_UNKNOWN = -1,
        DHCPOPT_PAD = 0,
        DHCPOPT_SUBNET_MASK = 1,
        DHCPOPT_TIME_OFFSET = 2,
        DHCPOPT_ROUTERS = 3,
        DHCPOPT_TIME_SERVERS = 4,
        DHCPOPT_NAME_SERVERS = 5,
        DHCPOPT_DOMAIN_NAME_SERVERS = 6,
        DHCPOPT_LOG_SERVERS = 7,
        DHCPOPT_QUOTES_SERVERS = 8,
        DHCPOPT_LPR_SERVERS = 9,
        DHCPOPT_IMPRESS_SERVERS = 10,
        DHCPOPT_RESOURCE_LOCATION_SERVERS = 11,
        DHCPOPT_HOST_NAME = 12,
        DHCPOPT_BOOT_SIZE = 13,
        DHCPOPT_MERIT_DUMP = 14,
        DHCPOPT_DOMAIN_NAME = 15,
        DHCPOPT_SWAP_SERVER = 16,
        DHCPOPT_ROOT_PATH = 17,
        DHCPOPT_EXTENSIONS_PATH = 18,
        DHCPOPT_IP_FORWARDING = 19,
        DHCPOPT_NON_LOCAL_SOURCE_ROUTING = 20,
        DHCPOPT_POLICY_FILTER = 21,
        DHCPOPT_MAX_DGRAM_REASSEMBLY = 22,
        DEFAULT_IP_TTL = 23,
        DHCPOPT_PATH_MTU_AGING_TIMEOUT = 24,
        PATH_MTU_PLATEAU_TABLE = 25,
        DHCPOPT_INTERFACE_MTU = 26,
        DHCPOPT_ALL_SUBNETS_LOCAL = 27,
        DHCPOPT_BROADCAST_ADDRESS = 28,
        DHCPOPT_PERFORM_MASK_DISCOVERY = 29,
        DHCPOPT_MASK_SUPPLIER = 30,
        DHCPOPT_ROUTER_DISCOVERY = 31,
        DHCPOPT_ROUTER_SOLICITATION_ADDRESS = 32,
        DHCPOPT_STATIC_ROUTES = 33,
        DHCPOPT_TRAILER_ENCAPSULATION = 34,
        DHCPOPT_ARP_CACHE_TIMEOUT = 35,
        DHCPOPT_IEEE802_3_ENCAPSULATION = 36,
        DHCPOPT_DEFAULT_TCP_TTL = 37,
        DHCPOPT_TCP_KEEPALIVE_INTERVAL = 38,
        DHCPOPT_TCP_KEEPALIVE_GARBAGE = 39,
        DHCPOPT_NIS_DOMAIN = 40,
        DHCPOPT_NIS_SERVERS = 41,
        DHCPOPT_NTP_SERVERS = 42,
        DHCPOPT_VENDOR_ENCAPSULATED_OPTIONS = 43,
        DHCPOPT_NETBIOS_NAME_SERVERS = 44,
        DHCPOPT_NETBIOS_DD_SERVER = 45,
        DHCPOPT_NETBIOS_NODE_TYPE = 46,
        DHCPOPT_NETBIOS_SCOPE = 47,
        DHCPOPT_FONT_SERVERS = 48,
        DHCPOPT_X_DISPLAY_MANAGER = 49,
        DHCPOPT_DHCP_REQUESTED_ADDRESS = 50,
        DHCPOPT_DHCP_LEASE_TIME = 51,
        DHCPOPT_DHCP_OPTION_OVERLOAD = 52,
        DHCPOPT_DHCP_MESSAGE_TYPE = 53,
        DHCPOPT_DHCP_SERVER_IDENTIFIER = 54,
        DHCPOPT_DHCP_PARAMETER_REQUEST_LIST = 55,
        DHCPOPT_DHCP_MESSAGE = 56,
        DHCPOPT_DHCP_MAX_MESSAGE_SIZE = 57,
        DHCPOPT_DHCP_RENEWAL_TIME = 58,
        DHCPOPT_DHCP_REBINDING_TIME = 59,
        DHCPOPT_VENDOR_CLASS_IDENTIFIER = 60,
        DHCPOPT_DHCP_CLIENT_IDENTIFIER = 61,
        DHCPOPT_NWIP_DOMAIN_NAME = 62,
        DHCPOPT_NWIP_SUBOPTIONS = 63,
        DHCPOPT_NIS_DOMAIN_NAME = 64,
        DHCPOPT_NIS_SERVER_ADDRESS = 65,
        DHCPOPT_TFTP_SERVER_NAME = 66,
        DHCPOPT_BOOTFILE_NAME = 67,
        DHCPOPT_HOME_AGENT_ADDRESS = 68,
        DHCPOPT_SMTP_SERVER = 69,
        DHCPOPT_POP3_SERVER = 70,
        DHCPOPT_NNTP_SERVER = 71,
        DHCPOPT_WWW_SERVER = 72,
        DHCPOPT_FINGER_SERVER = 73,
        DHCPOPT_IRC_SERVER = 74,
        DHCPOPT_STREETTALK_SERVER = 75,
        DHCPOPT_STDA_SERVER = 76,
        DHCPOPT_USER_CLASS = 77,
        DHCPOPT_DIRECTORY_AGENT = 78,
        DHCPOPT_SERVICE_SCOPE = 79,
        DHCPOPT_RAPID_COMMIT = 80,
        DHCPOPT_FQDN = 81,
        DHCPOPT_DHCP_AGENT_OPTIONS = 82,
        DHCPOPT_ISNS = 83,
        DHCPOPT_NDS_SERVERS = 85,
        DHCPOPT_NDS_TREE_NAME = 86,
        DHCPOPT_NDS_CONTEXT = 87,
        DHCPOPT_BCMCS_CONTROLLER_DOMAIN_NAME_LIST = 88,
        DHCPOPT_BCMCS_CONTROLLER_IPV4_ADDRESS = 89,
        DHCPOPT_AUTHENTICATION = 90,
        DHCPOPT_CLIENT_LAST_TXN_TIME = 91,
        DHCPOPT_ASSOCIATED_IP = 92,
        DHCPOPT_CLIENT_SYSTEM = 93,
        DHCPOPT_CLIENT_NDI = 94,
        DHCPOPT_LDAP = 95,
        DHCPOPT_UUID_GUID = 97,
        DHCPOPT_USER_AUTH = 98,
        DHCPOPT_GEOCONF_CIVIC = 99,
        DHCPOPT_PCODE = 100,
        DHCPOPT_TCODE = 101,
        DHCPOPT_NETINFO_ADDRESS = 112,
        DHCPOPT_NETINFO_TAG = 113,
        DHCPOPT_URL = 114,
        DHCPOPT_AUTO_CONFIG = 116,
        DHCPOPT_NAME_SERVICE_SEARCH = 117,
        DHCPOPT_SUBNET_SELECTION = 118,
        DHCPOPT_DOMAIN_SEARCH = 119,
        DHCPOPT_SIP_SERVERS = 120,
        DHCPOPT_CLASSLESS_STATIC_ROUTE = 121,
        DHCPOPT_CCC = 122,
        DHCPOPT_GEOCONF = 123,
        DHCPOPT_V_I_VENDOR_CLASS = 124,
        DHCPOPT_V_I_VENDOR_OPTS = 125,
        DHCPOPT_OPTION_PANA_AGENT = 136,
        DHCPOPT_OPTION_V4_LOST = 137,
        DHCPOPT_OPTION_CAPWAP_AC_V4 = 138,
        DHCPOPT_OPTION_IPV4_ADDRESS_MOS = 139,
        DHCPOPT_OPTION_IPV4_FQDN_MOS = 140,
        DHCPOPT_SIP_UA_CONFIG = 141,
        DHCPOPT_OPTION_IPV4_ADDRESS_ANDSF = 142,
        DHCPOPT_GEOLOC = 144,
        DHCPOPT_FORCERENEW_NONCE_CAPABLE = 145,
        DHCPOPT_RDNSS_SELECTION = 146,
        DHCPOPT_STATUS_CODE = 151,
        DHCPOPT_BASE_TIME = 152,
        DHCPOPT_START_TIME_OF_STATE = 153,
        DHCPOPT_QUERY_START_TIME = 154,
        DHCPOPT_QUERY_END_TIME = 155,
        DHCPOPT_DHCP_STATE = 156,
        DHCPOPT_DATA_SOURCE = 157,
        DHCPOPT_OPTION_V4_PCP_SERVER = 158,
        DHCPOPT_OPTION_V4_PORTPARAMS = 159,
        DHCPOPT_CAPTIVE_PORTAL = 160,
        DHCPOPT_OPTION_MUD_URL_V4 = 161,
        DHCPOPT_ETHERBOOT = 175,
        DHCPOPT_IP_TELEPHONE = 176,
        DHCPOPT_PXELINUX_MAGIC = 208,
        DHCPOPT_CONFIGURATION_FILE = 209,
        DHCPOPT_PATH_PREFIX = 210,
        DHCPOPT_REBOOT_TIME = 211,
        DHCPOPT_OPTION_6RD = 212,
        DHCPOPT_OPTION_V4_ACCESS_DOMAIN = 213,
        DHCPOPT_SUBNET_ALLOCATION = 220,
        DHCPOPT_VIRTUAL_SUBNET_SELECTION = 221,
        DHCPOPT_END = 255
    };


    class DhcpOption : public TLVRecord<uint8_t, uint8_t>
    {
    public:

        DhcpOption(uint8_t* optionRawData) : TLVRecord(optionRawData) { }

        virtual ~DhcpOption() { }

        IPv4Address getValueAsIpAddr() const
        {
            return getValueAs<uint32_t>();
        }

        void setValueIpAddr(const IPv4Address& addr, int valueOffset = 0)
        {
            setValue<uint32_t>(addr.toInt(), valueOffset);
        }

        std::string getValueAsString(int valueOffset = 0) const
        {
            if (m_Data->recordLen - valueOffset < 1)
                return "";

            return std::string((const char*)m_Data->recordValue + valueOffset, (int)m_Data->recordLen - valueOffset);
        }

        void setValueString(const std::string& stringValue, int valueOffset = 0)
        {
            // calculate the maximum length of the destination buffer
            size_t len = (size_t)m_Data->recordLen - (size_t)valueOffset;

            // use the length of input string if a buffer is large enough for whole string
            if (stringValue.length() < len)
                len = stringValue.length();

            memcpy(m_Data->recordValue + valueOffset, stringValue.data(), len);
        }


        // implement abstract methods

        size_t getTotalSize() const
        {
            if (m_Data->recordType == (uint8_t)DHCPOPT_END || m_Data->recordType == (uint8_t)DHCPOPT_PAD)
                return sizeof(uint8_t);

            return sizeof(uint8_t) * 2 + (size_t)m_Data->recordLen;
        }

        size_t getDataSize() const
        {
            if (m_Data->recordType == (uint8_t)DHCPOPT_END || m_Data->recordType == (uint8_t)DHCPOPT_PAD)
                return 0;

            return m_Data->recordLen;
        }
    };


    class DhcpOptionBuilder : public TLVRecordBuilder
    {
    public:

        DhcpOptionBuilder(DhcpOptionTypes optionType, const uint8_t* optionValue, uint8_t optionValueLen) :
            TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen) { }

        DhcpOptionBuilder(DhcpOptionTypes optionType, uint8_t optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) { }

        DhcpOptionBuilder(DhcpOptionTypes optionType, uint16_t optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) { }

        DhcpOptionBuilder(DhcpOptionTypes optionType, uint32_t optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) { }

        DhcpOptionBuilder(DhcpOptionTypes optionType, const IPv4Address& optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) { }

        DhcpOptionBuilder(DhcpOptionTypes optionType, const std::string& optionValue) :
            TLVRecordBuilder((uint8_t)optionType, optionValue) { }

        DhcpOptionBuilder(const DhcpOptionBuilder& other) :
            TLVRecordBuilder(other) { }

        DhcpOptionBuilder& operator=(const DhcpOptionBuilder& other)
        {
            TLVRecordBuilder::operator=(other);
            return *this;
        }

        DhcpOption build() const;
    };



    class DhcpLayer : public Layer
    {
    public:

        DhcpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);

        DhcpLayer(DhcpMessageType msgType, const MacAddress& clientMacAddr);

        DhcpLayer();

        virtual ~DhcpLayer() {}

        dhcp_header* getDhcpHeader() const { return (dhcp_header*)m_Data; }

        BootpOpCodes getOpCode() const { return (BootpOpCodes)getDhcpHeader()->opCode; }

        IPv4Address getClientIpAddress() const { return getDhcpHeader()->clientIpAddress; }

        void setClientIpAddress(const IPv4Address& addr) { getDhcpHeader()->clientIpAddress = addr.toInt(); }

        IPv4Address getServerIpAddress() const { return getDhcpHeader()->serverIpAddress; }

        void setServerIpAddress(const IPv4Address& addr) { getDhcpHeader()->serverIpAddress = addr.toInt(); }

        IPv4Address getYourIpAddress() const { return getDhcpHeader()->yourIpAddress; }

        void setYourIpAddress(const IPv4Address& addr) { getDhcpHeader()->yourIpAddress = addr.toInt(); }

        IPv4Address getGatewayIpAddress() const { return getDhcpHeader()->gatewayIpAddress; }

        void setGatewayIpAddress(const IPv4Address& addr) { getDhcpHeader()->gatewayIpAddress = addr.toInt(); }

        MacAddress getClientHardwareAddress() const;

        void setClientHardwareAddress(const MacAddress& addr);

        PCPP_DEPRECATED DhcpMessageType getMesageType() const { return getMessageType(); };

        DhcpMessageType getMessageType() const;

        bool setMesageType(DhcpMessageType msgType) { return setMessageType(msgType); };

        bool setMessageType(DhcpMessageType msgType);

        DhcpOption getFirstOptionData() const;

        DhcpOption getNextOptionData(DhcpOption dhcpOption) const;

        DhcpOption getOptionData(DhcpOptionTypes option) const;

        size_t getOptionsCount() const;

        DhcpOption addOption(const DhcpOptionBuilder& optionBuilder);

        DhcpOption addOptionAfter(const DhcpOptionBuilder& optionBuilder, DhcpOptionTypes prevOption);

        bool removeOption(DhcpOptionTypes optionType);

        bool removeAllOptions();

        // implement abstract methods

        void parseNextLayer() {}

        size_t getHeaderLen() const { return m_DataLen; }

        void computeCalculateFields();

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { return OsiModelApplicationLayer; }

    private:

        uint8_t* getOptionsBasePtr() const { return m_Data + sizeof(dhcp_header); }

        TLVRecordReader<DhcpOption> m_OptionReader;

        void initDhcpLayer(size_t numOfBytesToAllocate);

        DhcpOption addOptionAt(const DhcpOptionBuilder& optionBuilder, int offset);
    };
}

#endif /* PACKETPP_DHCP_LAYER */