dhcp_message.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_DHCP_MESSAGE_HPP
#define JOIN_FABRIC_DHCP_MESSAGE_HPP
 
// libjoin.
#include <join/dhcp_option.hpp>
#include <join/utils.hpp>
 
// C++.
#include <vector>
 
// C.
#include <net/ethernet.h>
#include <netinet/in.h>
#include <cstring>
 
namespace join
{
    struct DhcpPacket
    {
        MacAddress src;
 
        MacAddress dest;
 
        MacAddress hardware;
 
        IpAddress client{AF_INET};
 
        IpAddress your{AF_INET};
 
        IpAddress server{AF_INET};
 
        IpAddress gateway{AF_INET};
 
        uint32_t id = 0;
 
        uint16_t secs = 0;
 
        uint16_t flags = 0;
 
        uint8_t op = 0;
 
        DhcpOption options;
    };
 
    class DhcpMessage
    {
    public:
        enum MessageType : uint8_t
        {
            Discover = 1, 
            Offer = 2,    
            Request = 3,  
            Decline = 4,  
            Ack = 5,      
            Nak = 6,      
            Release = 7,  
            Inform = 8,   
        };
 
        enum Operation : uint8_t
        {
            BootRequest = 1, 
            BootReply = 2,   
        };
 
        enum Flag : uint16_t
        {
            BroadcastFlag = 0x8000, 
        };
 
        enum Overload : uint8_t
        {
            FileOverload = 1,  
            SnameOverload = 2, 
        };
 
        ssize_t serialize (const DhcpPacket& packet, char* data, size_t maxSize) const
        {
            if ((packet.op != BootRequest) && (packet.op != BootReply))
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            char* cur = data;
            const char* end = data + maxSize;
            bool ok = true;
 
            uint8_t head[4] = {packet.op, _ethernet, ETH_ALEN, 0};
            ok &= writeBytes (cur, end, head, sizeof (head));
 
            uint32_t id = htonl (packet.id);
            ok &= writeBytes (cur, end, &id, sizeof (id));
 
            uint16_t secs = htons (packet.secs);
            ok &= writeBytes (cur, end, &secs, sizeof (secs));
 
            uint16_t flags = htons (packet.flags);
            ok &= writeBytes (cur, end, &flags, sizeof (flags));
 
            ok &= writeAddress (cur, end, packet.client);
            ok &= writeAddress (cur, end, packet.your);
            ok &= writeAddress (cur, end, packet.server);
            ok &= writeAddress (cur, end, packet.gateway);
 
            char chaddr[_chaddrSize] = {};
            ::memcpy (chaddr, packet.hardware.addr (), ETH_ALEN);
            ok &= writeBytes (cur, end, chaddr, sizeof (chaddr));
 
            char padding[_snameSize + _fileSize] = {};
            ok &= writeBytes (cur, end, padding, sizeof (padding));
 
            uint32_t cookie = htonl (magicCookie);
            ok &= writeBytes (cur, end, &cookie, sizeof (cookie));
 
            if (!ok || (serialize (packet.options, cur, end) == -1))
            {
                return -1;
            }
 
            const size_t written = static_cast<size_t> (cur - data);
            if (written < minMsgSize)
            {
                const char pad[minMsgSize] = {};
                if (!writeBytes (cur, end, pad, minMsgSize - written))
                {
                    return -1;
                }
            }
 
            return cur - data;
        }
 
        int deserialize (DhcpPacket& packet, const char* data, size_t size) const
        {
            packet.options.clear ();
 
            const char* cur = data;
            const char* end = data + size;
 
            uint8_t head[4] = {};
            if (!readBytes (cur, end, head, sizeof (head)))
            {
                return -1;
            }
 
            packet.op = head[0];
            if (((packet.op != BootRequest) && (packet.op != BootReply)) || (head[1] != _ethernet) ||
                (head[2] != ETH_ALEN))
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            uint32_t id = 0;
            uint16_t secs = 0, flags = 0;
 
            if (!readBytes (cur, end, &id, sizeof (id)) || !readBytes (cur, end, &secs, sizeof (secs)) ||
                !readBytes (cur, end, &flags, sizeof (flags)))
            {
                return -1;
            }
 
            packet.id = ntohl (id);
            packet.secs = ntohs (secs);
            packet.flags = ntohs (flags);
 
            if (!readAddress (cur, end, packet.client) || !readAddress (cur, end, packet.your) ||
                !readAddress (cur, end, packet.server) || !readAddress (cur, end, packet.gateway))
            {
                return -1;
            }
 
            uint8_t chaddr[_chaddrSize] = {};
            if (!readBytes (cur, end, chaddr, sizeof (chaddr)))
            {
                return -1;
            }
 
            packet.hardware = MacAddress (chaddr, ETH_ALEN);
 
            char sname[_snameSize] = {}, file[_fileSize] = {};
            uint32_t cookie = 0;
 
            if (!readBytes (cur, end, sname, sizeof (sname)) || !readBytes (cur, end, file, sizeof (file)) ||
                !readBytes (cur, end, &cookie, sizeof (cookie)))
            {
                return -1;
            }
 
            if (ntohl (cookie) != magicCookie)
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            if (deserialize (packet.options, cur, end) == -1)
            {
                return -1;
            }
 
            const uint8_t* overload = packet.options.getIf<uint8_t> (DhcpOption::OptionOverload);
            if (overload != nullptr)
            {
                if ((*overload & FileOverload) && (deserialize (packet.options, file, file + sizeof (file)) == -1))
                {
                    return -1;
                }
 
                if ((*overload & SnameOverload) && (deserialize (packet.options, sname, sname + sizeof (sname)) == -1))
                {
                    return -1;
                }
            }
 
            return 0;
        }
 
        static constexpr uint32_t magicCookie = 0x63825363;
 
        static constexpr size_t headerSize = 240;
 
        static constexpr size_t minMsgSize = 300;
 
        static constexpr size_t maxOptionSize = 255;
 
    protected:
        int serialize (const DhcpOption& options, char*& cur, const char* end) const;
 
        int deserialize (DhcpOption& options, const char* cur, const char* end) const;
 
        static bool writeHead (char*& cur, const char* end, uint8_t code, size_t size);
 
        static bool writeAddress (char*& cur, const char* end, const IpAddress& address)
        {
            struct in_addr addr = {};
 
            if (address.family () == AF_INET)
            {
                ::memcpy (&addr, address.addr (), sizeof (addr));
            }
 
            return writeBytes (cur, end, &addr, sizeof (addr));
        }
 
        static bool readAddress (const char*& cur, const char* end, IpAddress& address)
        {
            struct in_addr addr = {};
 
            if (!readBytes (cur, end, &addr, sizeof (addr)))
            {
                return false;
            }
 
            address = IpAddress (&addr, sizeof (addr));
 
            return true;
        }
 
        static constexpr uint8_t _ethernet = 1;
 
        static constexpr size_t _chaddrSize = 16;
 
        static constexpr size_t _snameSize = 64;
 
        static constexpr size_t _fileSize = 128;
    };
}
 
#endif