dhcp.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_DHCP_HPP
#define JOIN_FABRIC_DHCP_HPP
 
// libjoin.
#include <join/dhcp_protocol.hpp>
#include <join/dhcp_message.hpp>
#include <join/condition.hpp>
#include <join/reactor.hpp>
#include <join/utils.hpp>
#include <join/error.hpp>
#include <join/arp.hpp>
 
// C++.
#include <unordered_map>
#include <system_error>
#include <chrono>
#include <string>
#include <vector>
 
// C.
#include <net/ethernet.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <net/if.h>
 
namespace join
{
    template <class Protocol>
    class BasicDhcp : public EventHandler
    {
    public:
        using Socket = typename Protocol::Socket;
 
        BasicDhcp () = delete;
 
        explicit BasicDhcp (const std::string& interface, Reactor& reactor = ReactorThread::reactor ())
        : _buffer (std::make_unique<char[]> (sizeof (Frame) + Protocol::maxMsgSize))
        , _interface (interface)
        , _hardware (MacAddress::address (interface))
        , _reactor (reactor)
        {
            if (::if_nametoindex (_interface.c_str ()) == 0)
            {
                throw std::system_error (errno, std::system_category (), "dhcp interface lookup failed");
            }
 
            if (_socket.bind (_interface) == -1 || _socket.setOption (Socket::Broadcast, 1) == -1)
            {
                throw std::system_error (lastError, "dhcp socket setup failed");  // LCOV_EXCL_LINE
            }
 
            _reactor.addHandler (_socket.handle (), this);
        }
 
        BasicDhcp (const BasicDhcp& other) = delete;
 
        BasicDhcp& operator= (const BasicDhcp& other) = delete;
 
        BasicDhcp (BasicDhcp&& other) = delete;
 
        BasicDhcp& operator= (BasicDhcp&& other) = delete;
 
        virtual ~BasicDhcp ()
        {
            _reactor.delHandler (_socket.handle ());
        }
 
        const std::string& interface () const noexcept
        {
            return _interface;
        }
 
        const MacAddress& hardware () const noexcept
        {
            return _hardware;
        }
 
    protected:
        struct __attribute__ ((packed)) Frame
        {
            struct ethhdr eth;
            struct iphdr ip;
            struct udphdr udp;
        };
 
        struct __attribute__ ((packed)) Pseudo
        {
            uint32_t source;
            uint32_t destination;
            uint8_t zero;
            uint8_t protocol;
            uint16_t length;
        };
 
        virtual void onMessage (DhcpPacket::Ptr packet) = 0;
 
        void onReadable ([[maybe_unused]] int fd) override final
        {
            ssize_t size = _socket.read (_buffer.get (), sizeof (Frame) + Protocol::maxMsgSize);
            if (size <= 0)
            {
                return;  // LCOV_EXCL_LINE
            }
 
            DhcpPacket::Ptr packet = receive (_buffer.get (), static_cast<size_t> (size));
            if (packet != nullptr)
            {
                onMessage (std::move (packet));
            }
        }
 
        static uint16_t udpChecksum (const Frame& frame, const char* payload, size_t size)
        {
            Pseudo pseudo = {};
            pseudo.source = frame.ip.saddr;
            pseudo.destination = frame.ip.daddr;
            pseudo.protocol = IPPROTO_UDP;
            pseudo.length = frame.udp.len;
 
            std::vector<uint8_t> scratch (sizeof (pseudo) + sizeof (frame.udp) + size, 0);
            ::memcpy (scratch.data (), &pseudo, sizeof (pseudo));
            ::memcpy (scratch.data () + sizeof (pseudo), &frame.udp, sizeof (frame.udp));
            ::memcpy (scratch.data () + sizeof (pseudo) + sizeof (frame.udp), payload, size);
 
            uint16_t sum = join::checksum (reinterpret_cast<const uint16_t*> (scratch.data ()), scratch.size ());
 
            return sum ? sum : 0xffff;
        }
 
        int transmit (const DhcpPacket& packet, const IpAddress& source, const IpAddress& destination)
        {
            std::stringstream data;
            if (_message.serialize (packet, data) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            const std::string payload = data.str ();
 
            if (payload.size () > Protocol::maxMsgSize)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::MessageTooLong);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            const size_t size = sizeof (Frame) + payload.size ();
 
            std::vector<char> buffer (size, 0);
            Frame* frame = reinterpret_cast<Frame*> (buffer.data ());
            ::memcpy (buffer.data () + sizeof (Frame), payload.data (), payload.size ());
 
            const bool boot = (packet.op == DhcpMessage::BootRequest);
            const uint16_t datagram = static_cast<uint16_t> (sizeof (frame->udp) + payload.size ());
 
            frame->udp.source = htons (boot ? Protocol::clientPort : Protocol::serverPort);
            frame->udp.dest = htons (boot ? Protocol::serverPort : Protocol::clientPort);
            frame->udp.len = htons (datagram);
            frame->udp.check = 0;
 
            frame->ip.version = IPVERSION;
            frame->ip.ihl = sizeof (frame->ip) >> 2;
            frame->ip.tos = IPTOS_CLASS_CS6 | IPTOS_ECN_NOT_ECT;
            frame->ip.tot_len = htons (static_cast<uint16_t> (sizeof (frame->ip) + datagram));
            frame->ip.frag_off = htons (IP_DF);
            frame->ip.ttl = IPDEFTTL;
            frame->ip.protocol = IPPROTO_UDP;
            ::memcpy (&frame->ip.saddr, source.addr (), sizeof (frame->ip.saddr));
            ::memcpy (&frame->ip.daddr, destination.addr (), sizeof (frame->ip.daddr));
            frame->ip.check = 0;
            frame->ip.check = join::checksum (reinterpret_cast<const uint16_t*> (&frame->ip), sizeof (frame->ip));
 
            frame->udp.check = udpChecksum (*frame, payload.data (), payload.size ());
 
            ::memcpy (frame->eth.h_dest, packet.dest.addr (), ETH_ALEN);
            ::memcpy (frame->eth.h_source, packet.src.addr (), ETH_ALEN);
            frame->eth.h_proto = htons (ETH_P_IP);
 
            return (_socket.write (buffer.data (), size) == -1) ? -1 : 0;
        }
 
        DhcpPacket::Ptr receive (const char* data, size_t size) const
        {
            if (size < sizeof (Frame) + DhcpMessage::headerSize)
            {
                return nullptr;
            }
 
            Frame frame;
            ::memcpy (&frame, data, sizeof (frame));
 
            if ((frame.eth.h_proto != htons (ETH_P_IP)) || (frame.ip.version != IPVERSION) ||
                (frame.ip.ihl != (sizeof (frame.ip) >> 2)) || (frame.ip.protocol != IPPROTO_UDP))
            {
                return nullptr;
            }
 
            struct iphdr header = frame.ip;
            const uint16_t check = header.check;
            header.check = 0;
 
            if (check != join::checksum (reinterpret_cast<const uint16_t*> (&header), sizeof (header)))
            {
                return nullptr;
            }
 
            if (((frame.udp.source != htons (Protocol::serverPort)) ||
                 (frame.udp.dest != htons (Protocol::clientPort))) &&
                ((frame.udp.source != htons (Protocol::clientPort)) ||
                 (frame.udp.dest != htons (Protocol::serverPort))))
            {
                return nullptr;
            }
 
            const size_t datagram = ntohs (frame.udp.len);
            const size_t available = size - sizeof (frame.eth) - sizeof (frame.ip);
 
            if ((datagram < sizeof (frame.udp)) || (datagram > available))
            {
                return nullptr;
            }
 
            const char* payload = data + sizeof (Frame);
            const size_t payloadSize = datagram - sizeof (frame.udp);
 
            if (frame.udp.check)
            {
                Frame probe = frame;
                probe.udp.check = 0;
 
                if (frame.udp.check != udpChecksum (probe, payload, payloadSize))
                {
                    return nullptr;
                }
            }
 
            std::stringstream stream;
            stream.rdbuf ()->pubsetbuf (const_cast<char*> (payload), payloadSize);
 
            DhcpPacket::Ptr packet = std::make_unique<DhcpPacket> ();
            if (_message.deserialize (*packet, stream) == -1)
            {
                return nullptr;
            }
 
            packet->src = MacAddress (frame.eth.h_source, ETH_ALEN);
            packet->dest = MacAddress (frame.eth.h_dest, ETH_ALEN);
 
            return packet;
        }
 
        Socket _socket;
 
        DhcpMessage _message;
 
        std::unique_ptr<char[]> _buffer;
 
        const std::string _interface;
 
        const MacAddress _hardware;
 
        Reactor& _reactor;
    };
 
    template <class Protocol>
    class BasicDhcpClient : public BasicDhcp<Protocol>
    {
    public:
        using BasicDhcp<Protocol>::hardware;
        using BasicDhcp<Protocol>::interface;
        using BasicDhcp<Protocol>::transmit;
 
        BasicDhcpClient () = delete;
 
        explicit BasicDhcpClient (const std::string& interface, uint16_t maxSize = 0, const std::string& hostname = {},
                                  Reactor& reactor = ReactorThread::reactor ())
        : BasicDhcp<Protocol> (interface, reactor)
        , _hostname (hostname)
        , _maxSize (maxSize)
        {
            if (maxSize && !DhcpOption::isValid (DhcpOption::MaximumDhcpMessageSize, maxSize))
            {
                throw std::system_error (make_error_code (Errc::InvalidParam),
                                         "dhcp maximum message size is too small");
            }
        }
 
        virtual ~BasicDhcpClient () = default;
 
        DhcpPacket compose (uint8_t type) const
        {
            DhcpPacket packet;
 
            packet.op = DhcpMessage::BootRequest;
            packet.id = randomize<uint32_t> ();
            packet.hardware = hardware ();
            packet.src = hardware ();
            packet.dest = MacAddress::broadcast;
 
            packet.options.insert (DhcpOption::DhcpMessageType, type);
            packet.options.insert (DhcpOption::ClientIdentifier, hardware ());
 
            if (!_hostname.empty ())
            {
                packet.options.insert (DhcpOption::HostName, _hostname);
            }
 
            if (_maxSize)
            {
                packet.options.insert (DhcpOption::MaximumDhcpMessageSize, _maxSize);
            }
 
            return packet;
        }
 
        DhcpPacket::Ptr exchange (DhcpPacket& request, const IpAddress& destination, uint8_t expected,
                                  std::chrono::milliseconds timeout = std::chrono::seconds (1))
        {
            ScopedLock<Mutex> lock (_syncMutex);
 
            _reason.clear ();
 
            auto inserted = _pending.emplace (request.id, std::make_unique<PendingRequest> ());
            if (!inserted.second)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::InUse);
                return nullptr;
                // LCOV_EXCL_STOP
            }
 
            PendingRequest* pending = inserted.first->second.get ();
 
            if (transmit (request, request.client, destination) == -1)
            {
                // LCOV_EXCL_START
                _pending.erase (request.id);
                return nullptr;
                // LCOV_EXCL_STOP
            }
 
            if (!pending->cond.timedWait (lock, timeout, [pending] {
                    return pending->answer != nullptr;
                }))
            {
                _pending.erase (request.id);
                lastError = make_error_code (Errc::TimedOut);
                return nullptr;
            }
 
            DhcpPacket::Ptr answer = std::move (pending->answer);
            _pending.erase (request.id);
 
            const uint8_t* type = answer->options.getIf<uint8_t> (DhcpOption::DhcpMessageType);
            if (type == nullptr)
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return nullptr;
            }
 
            if (*type == DhcpMessage::Nak)
            {
                const std::string* message = answer->options.getIf<std::string> (DhcpOption::Message);
                if (message != nullptr)
                {
                    _reason = *message;
                }
 
                lastError = make_error_code (Errc::ConnectionRefused);
                return nullptr;
            }
 
            if (*type != expected)
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return nullptr;
            }
 
            return answer;
        }
 
        std::string reason () const
        {
            ScopedLock<Mutex> lock (_syncMutex);
 
            return _reason;
        }
 
        DhcpPacket::Ptr discover (const IpAddress& wants = IpAddress::ipv4Wildcard,
                                  std::chrono::milliseconds timeout = std::chrono::seconds (1))
        {
            DhcpPacket out = compose (DhcpMessage::Discover);
 
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
 
            if (!wants.isWildcard ())
            {
                out.options.insert (DhcpOption::RequestedIpAddress, wants);
            }
 
            return exchange (out, IpAddress::ipv4Broadcast, DhcpMessage::Offer, timeout);
        }
 
        DhcpPacket::Ptr request (const IpAddress& wants, const IpAddress& server,
                                 std::chrono::milliseconds timeout = std::chrono::seconds (1))
        {
            DhcpPacket out = compose (DhcpMessage::Request);
 
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
            out.options.insert (DhcpOption::RequestedIpAddress, wants);
            out.options.insert (DhcpOption::ServerIdentifier, server);
 
            return exchange (out, IpAddress::ipv4Broadcast, DhcpMessage::Ack, timeout);
        }
 
        DhcpPacket::Ptr renew (const IpAddress& client, const IpAddress& server,
                               std::chrono::milliseconds timeout = std::chrono::seconds (1))
        {
            MacAddress mac = Arp::get (interface (), server, timeout);
            if (mac.isWildcard ())
            {
                return nullptr;
            }
 
            DhcpPacket out = compose (DhcpMessage::Request);
 
            out.dest = mac;
            out.client = client;
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
 
            return exchange (out, server, DhcpMessage::Ack, timeout);
        }
 
        DhcpPacket::Ptr inform (const IpAddress& client, std::chrono::milliseconds timeout = std::chrono::seconds (1))
        {
            DhcpPacket out = compose (DhcpMessage::Inform);
 
            out.client = client;
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
 
            return exchange (out, IpAddress::ipv4Broadcast, DhcpMessage::Ack, timeout);
        }
 
        int release (const IpAddress& client, const IpAddress& server,
                     std::chrono::milliseconds timeout = std::chrono::seconds (1))
        {
            MacAddress mac = Arp::get (interface (), server, timeout);
            if (mac.isWildcard ())
            {
                return -1;
            }
 
            DhcpPacket out = compose (DhcpMessage::Release);
 
            out.dest = mac;
            out.client = client;
            out.options.insert (DhcpOption::ServerIdentifier, server);
 
            return transmit (out, client, server);
        }
 
        int decline (const IpAddress& address, const IpAddress& server, const std::string& message = {})
        {
            DhcpPacket out = compose (DhcpMessage::Decline);
 
            out.options.insert (DhcpOption::RequestedIpAddress, address);
            out.options.insert (DhcpOption::ServerIdentifier, server);
 
            if (!message.empty ())
            {
                out.options.insert (DhcpOption::Message, message);
            }
 
            return transmit (out, IpAddress::ipv4Wildcard, IpAddress::ipv4Broadcast);
        }
 
    protected:
        void onMessage (DhcpPacket::Ptr packet) override final
        {
            if (packet->op != DhcpMessage::BootReply)
            {
                return;
            }
 
            ScopedLock<Mutex> lock (_syncMutex);
 
            auto it = _pending.find (packet->id);
            if (it != _pending.end ())
            {
                it->second->answer = std::move (packet);
                it->second->cond.signal ();
            }
        }
 
        struct PendingRequest
        {
            Condition cond;
 
            DhcpPacket::Ptr answer;
        };
 
        static const ByteList _defaultParams;
 
        std::unordered_map<uint32_t, std::unique_ptr<PendingRequest>> _pending;
 
        mutable Mutex _syncMutex;
 
        std::string _reason;
 
        const std::string _hostname;
 
        const uint16_t _maxSize;
    };
 
    template <class Protocol>
    const ByteList BasicDhcpClient<Protocol>::_defaultParams = {DhcpOption::SubnetMask,       DhcpOption::Router,
                                                                DhcpOption::DomainNameServer, DhcpOption::DomainName,
                                                                DhcpOption::BroadcastAddress, DhcpOption::InterfaceMtu};
 
    template <class Protocol>
    class BasicDhcpServer : public BasicDhcp<Protocol>
    {
    public:
        using BasicDhcp<Protocol>::hardware;
        using BasicDhcp<Protocol>::interface;
        using BasicDhcp<Protocol>::transmit;
 
        BasicDhcpServer () = delete;
 
        explicit BasicDhcpServer (const std::string& interface, Reactor& reactor = ReactorThread::reactor ())
        : BasicDhcp<Protocol> (interface, reactor)
        {
        }
 
        virtual ~BasicDhcpServer () = default;
 
        int offer (const DhcpPacket& request, const IpAddress& address, const DhcpOption& options = {})
        {
            return reply (request, DhcpMessage::Offer, address, options);
        }
 
        int ack (const DhcpPacket& request, const IpAddress& address, const DhcpOption& options = {})
        {
            return reply (request, DhcpMessage::Ack, address, options);
        }
 
        int nak (const DhcpPacket& request, const std::string& message = {})
        {
            DhcpOption options;
 
            if (!message.empty ())
            {
                options.insert (DhcpOption::Message, message);
            }
 
            return reply (request, DhcpMessage::Nak, IpAddress::ipv4Wildcard, options);
        }
 
    protected:
        virtual void onDiscover (const DhcpPacket& request) = 0;
 
        virtual void onRequest (const DhcpPacket& request) = 0;
 
        virtual void onRelease (const DhcpPacket& request) = 0;
 
        virtual void onDecline (const DhcpPacket& request) = 0;
 
        virtual void onInform (const DhcpPacket& request) = 0;
 
        void onMessage (DhcpPacket::Ptr packet) override final
        {
            if (packet->op != DhcpMessage::BootRequest)
            {
                return;
            }
 
            const uint8_t* type = packet->options.getIf<uint8_t> (DhcpOption::DhcpMessageType);
            if (type == nullptr)
            {
                return;
            }
 
            switch (*type)
            {
                case DhcpMessage::Discover:
                    onDiscover (*packet);
                    break;
 
                case DhcpMessage::Request:
                    onRequest (*packet);
                    break;
 
                case DhcpMessage::Release:
                    onRelease (*packet);
                    break;
 
                case DhcpMessage::Decline:
                    onDecline (*packet);
                    break;
 
                case DhcpMessage::Inform:
                    onInform (*packet);
                    break;
 
                default:
                    break;
            }
        }
 
        int reply (const DhcpPacket& request, uint8_t type, const IpAddress& address, const DhcpOption& options)
        {
            const IpAddress server = IpAddress::ipv4Address (interface ());
            if (server.isWildcard ())
            {
                lastError = std::make_error_code (std::errc::address_not_available);
                return -1;
            }
 
            DhcpPacket out;
            out.op = DhcpMessage::BootReply;
            out.id = request.id;
            out.flags = request.flags;
            out.hardware = request.hardware;
 
            if (type == DhcpMessage::Ack)
            {
                out.client = request.client;
            }
            out.your = address;
            out.server = server;
            out.gateway = request.gateway;
            out.src = hardware ();
 
            out.options.insert (DhcpOption::DhcpMessageType, type);
            out.options.insert (DhcpOption::ServerIdentifier, server);
            out.options.insert (options.begin (), options.end ());
 
            const bool broadcast =
                (type == DhcpMessage::Nak) || (request.client.isWildcard () &&
                                               ((request.flags & DhcpMessage::BroadcastFlag) || address.isWildcard ()));
 
            out.dest = broadcast ? MacAddress::broadcast : request.hardware;
 
            const IpAddress& unicast = request.client.isWildcard () ? address : request.client;
 
            return transmit (out, server, broadcast ? IpAddress::ipv4Broadcast : unicast);
        }
    };
}
 
#endif