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>
 
// C++.
#include <sstream>
#include <memory>
#include <vector>
 
// C.
#include <net/ethernet.h>
#include <netinet/in.h>
#include <cstring>
 
namespace join
{
    struct DhcpPacket
    {
        using Ptr = std::unique_ptr<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, 
        };
 
        int serialize (const DhcpPacket& packet, std::stringstream& data) const
        {
            if ((packet.op != BootRequest) && (packet.op != BootReply))
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            const std::streampos start = data.tellp ();
 
            uint8_t head[4] = {packet.op, _ethernet, ETH_ALEN, 0};
            data.write (reinterpret_cast<const char*> (head), sizeof (head));
 
            uint32_t id = htonl (packet.id);
            data.write (reinterpret_cast<const char*> (&id), sizeof (id));
 
            uint16_t secs = htons (packet.secs);
            data.write (reinterpret_cast<const char*> (&secs), sizeof (secs));
 
            uint16_t flags = htons (packet.flags);
            data.write (reinterpret_cast<const char*> (&flags), sizeof (flags));
 
            writeAddress (data, packet.client);
            writeAddress (data, packet.your);
            writeAddress (data, packet.server);
            writeAddress (data, packet.gateway);
 
            char chaddr[_chaddrSize] = {};
            ::memcpy (chaddr, packet.hardware.addr (), ETH_ALEN);
            data.write (chaddr, sizeof (chaddr));
 
            char padding[_snameSize + _fileSize] = {};
            data.write (padding, sizeof (padding));
 
            uint32_t cookie = htonl (magicCookie);
            data.write (reinterpret_cast<const char*> (&cookie), sizeof (cookie));
 
            if (serialize (packet.options, data) == -1)
            {
                return -1;
            }
 
            const std::streamoff written = data.tellp () - start;
            if (written < static_cast<std::streamoff> (minMsgSize))
            {
                const std::string pad (static_cast<size_t> (minMsgSize - written), static_cast<char> (DhcpOption::Pad));
                data.write (pad.data (), pad.size ());
            }
 
            return 0;
        }
 
        int deserialize (DhcpPacket& packet, std::stringstream& data) const
        {
            packet.options.clear ();
 
            uint8_t head[4] = {};
            if (!extract (data, 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 (!extract (data, &id, sizeof (id)) || !extract (data, &secs, sizeof (secs)) ||
                !extract (data, &flags, sizeof (flags)))
            {
                return -1;
            }
 
            packet.id = ntohl (id);
            packet.secs = ntohs (secs);
            packet.flags = ntohs (flags);
 
            if (!readAddress (data, packet.client) || !readAddress (data, packet.your) ||
                !readAddress (data, packet.server) || !readAddress (data, packet.gateway))
            {
                return -1;
            }
 
            uint8_t chaddr[_chaddrSize] = {};
            if (!extract (data, chaddr, sizeof (chaddr)))
            {
                return -1;
            }
 
            packet.hardware = MacAddress (chaddr, ETH_ALEN);
 
            char sname[_snameSize] = {}, file[_fileSize] = {};
            uint32_t cookie = 0;
 
            if (!extract (data, sname, sizeof (sname)) || !extract (data, file, sizeof (file)) ||
                !extract (data, &cookie, sizeof (cookie)))
            {
                return -1;
            }
 
            if (ntohl (cookie) != magicCookie)
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            if (deserialize (packet.options, data) == -1)
            {
                return -1;
            }
 
            const uint8_t* overload = packet.options.getIf<uint8_t> (DhcpOption::OptionOverload);
            if (overload != nullptr)
            {
                if ((*overload & FileOverload) && !deserialize (packet.options, file, sizeof (file)))
                {
                    return -1;
                }
 
                if ((*overload & SnameOverload) && !deserialize (packet.options, sname, sizeof (sname)))
                {
                    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, std::stringstream& data) const;
 
        int deserialize (DhcpOption& options, std::stringstream& data) const;
 
        bool deserialize (DhcpOption& options, const char* field, size_t size) const
        {
            std::stringstream data;
            data.rdbuf ()->pubsetbuf (const_cast<char*> (field), size);
            return (deserialize (options, data) != -1);
        }
 
        static bool writeHead (std::ostream& data, uint8_t code, size_t size);
 
        static void writeAddress (std::ostream& data, const IpAddress& address)
        {
            struct in_addr addr = {};
 
            if (address.family () == AF_INET)
            {
                ::memcpy (&addr, address.addr (), sizeof (addr));
            }
 
            data.write (reinterpret_cast<const char*> (&addr), sizeof (addr));
        }
 
        static bool readAddress (std::istream& data, IpAddress& address)
        {
            struct in_addr addr = {};
 
            if (!extract (data, &addr, sizeof (addr)))
            {
                return false;
            }
 
            address = IpAddress (&addr, sizeof (addr));
 
            return true;
        }
 
        static bool extract (std::istream& data, void* out, size_t size)
        {
            data.read (reinterpret_cast<char*> (out), size);
 
            if (data.fail ())
            {
                lastError = make_error_code (Errc::MessageTooLong);
                return false;
            }
 
            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