DhcpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "TLVData.h"
#include "IpAddress.h"
#include "MacAddress.h"
#include <string.h>
 
 
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)
    static_assert(sizeof(dhcp_header) == 240, "dhcp_header size is not 240 bytes");
 
    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:
        explicit DhcpOption(uint8_t* optionRawData) : TLVRecord(optionRawData)
        {}
 
        ~DhcpOption() override = default;
 
        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
        {
            // TODO: This will burn if valueOffset is negative.
            // Should negative offsets even be allowed? Potentially change it to size_t?
            if (m_Data == nullptr || getDataSize() < static_cast<size_t>(valueOffset) + 1)
                return "";
 
            return std::string(reinterpret_cast<const char*>(m_Data->recordValue) + valueOffset,
                               static_cast<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 = static_cast<size_t>(m_Data->recordLen) - static_cast<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);
        }
 
        static bool canAssign(const uint8_t* recordRawData, size_t tlvDataLen)
        {
            auto data = reinterpret_cast<TLVRawData const*>(recordRawData);
            if (data == nullptr)
                return false;
 
            if (tlvDataLen < sizeof(TLVRawData::recordType))
                return false;
 
            if (data->recordType == static_cast<uint8_t>(DHCPOPT_END) ||
                data->recordType == static_cast<uint8_t>(DHCPOPT_PAD))
                return true;
 
            return TLVRecord<uint8_t, uint8_t>::canAssign(recordRawData, tlvDataLen);
        }
 
        // implement abstract methods
 
        size_t getTotalSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            if (m_Data->recordType == static_cast<uint8_t>(DHCPOPT_END) ||
                m_Data->recordType == static_cast<uint8_t>(DHCPOPT_PAD))
                return sizeof(uint8_t);
 
            return sizeof(uint8_t) * 2 + static_cast<size_t>(m_Data->recordLen);
        }
 
        size_t getDataSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            if (m_Data->recordType == static_cast<uint8_t>(DHCPOPT_END) ||
                m_Data->recordType == static_cast<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(static_cast<uint8_t>(optionType), optionValue, optionValueLen)
        {}
 
        DhcpOptionBuilder(DhcpOptionTypes optionType, uint8_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        DhcpOptionBuilder(DhcpOptionTypes optionType, uint16_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        DhcpOptionBuilder(DhcpOptionTypes optionType, uint32_t optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        DhcpOptionBuilder(DhcpOptionTypes optionType, const IPv4Address& optionValue)
            : TLVRecordBuilder(static_cast<uint8_t>(optionType), optionValue)
        {}
 
        DhcpOptionBuilder(DhcpOptionTypes optionType, const std::string& optionValue)
            : TLVRecordBuilder(static_cast<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();
 
        ~DhcpLayer() override = default;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<dhcp_header>(data, dataLen);
        }
 
        dhcp_header* getDhcpHeader() const
        {
            return reinterpret_cast<dhcp_header*>(m_Data);
        }
 
        BootpOpCodes getOpCode() const
        {
            return static_cast<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);
 
        DhcpMessageType getMessageType() const;
 
        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();
 
        static inline bool isDhcpPorts(uint16_t portSrc, uint16_t portDst);
 
        // 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(dhcp_header);
        }
 
        TLVRecordReader<DhcpOption> m_OptionReader;
 
        void initDhcpLayer(size_t numOfBytesToAllocate);
 
        DhcpOption addOptionAt(const DhcpOptionBuilder& optionBuilder, int offset);
    };
 
    // implementation of inline methods
 
    bool DhcpLayer::isDhcpPorts(uint16_t portSrc, uint16_t portDst)
    {
        return ((portSrc == 68 && portDst == 67) || (portSrc == 67 && portDst == 68) ||
                (portSrc == 67 && portDst == 67));
    }
 
}  // namespace pcpp