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/function.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 <memory>
#include <string>
 
// C.
#include <net/ethernet.h>
#include <netinet/udp.h>
#include <netinet/ip.h>
#include <sys/uio.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[]> (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
            }
        }
 
        BasicDhcp (const BasicDhcp& other) = delete;
 
        BasicDhcp& operator= (const BasicDhcp& other) = delete;
 
        BasicDhcp (BasicDhcp&& other) = delete;
 
        BasicDhcp& operator= (BasicDhcp&& other) = delete;
 
        virtual ~BasicDhcp () = default;
 
        const std::string& interface () const noexcept
        {
            return _interface;
        }
 
        const MacAddress& hardware () const noexcept
        {
            return _hardware;
        }
 
    protected:
        struct __attribute__ ((packed, aligned (2))) Frame
        {
            struct ethhdr eth;
            struct iphdr ip;
            struct udphdr udp;
        };
 
        struct __attribute__ ((packed, aligned (2))) Pseudo
        {
            uint32_t source;
            uint32_t destination;
            uint8_t zero;
            uint8_t protocol;
            uint16_t length;
        };
 
        void attach ()
        {
            if (_reactor.addHandler (_socket.handle (), this) == -1)
            {
                throw std::system_error (lastError, "dhcp reactor registration failed");  // LCOV_EXCL_LINE
            }
        }
 
        void detach () noexcept
        {
            _reactor.delHandler (_socket.handle ());
        }
 
        static uint16_t udpChecksum (const Frame& frame, const char* payload, size_t size) noexcept
        {
            Pseudo pseudo = {};
            pseudo.source = frame.ip.saddr;
            pseudo.destination = frame.ip.daddr;
            pseudo.protocol = IPPROTO_UDP;
            pseudo.length = frame.udp.len;
 
            uint16_t sum = join::checksum (reinterpret_cast<const uint16_t*> (&pseudo), sizeof (pseudo));
            sum = join::checksum (reinterpret_cast<const uint16_t*> (&frame.udp), sizeof (frame.udp),
                                  static_cast<uint16_t> (~sum));
            sum = join::checksum (reinterpret_cast<const uint16_t*> (payload), size, static_cast<uint16_t> (~sum));
 
            return sum ? sum : 0xffff;
        }
 
        int send (const char* data, size_t size, const MacAddress& to, const IpAddress& source,
                  const IpAddress& destination) noexcept
        {
            if (size > Protocol::maxMsgSize)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::MessageTooLong);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            Frame frame = {};
 
            const bool boot = (size > 0) && (static_cast<uint8_t> (data[0]) == DhcpMessage::BootRequest);
            const uint16_t datagram = static_cast<uint16_t> (sizeof (frame.udp) + 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.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 = join::checksum (reinterpret_cast<const uint16_t*> (&frame.ip), sizeof (frame.ip));
 
            frame.udp.check = udpChecksum (frame, data, size);
 
            ::memcpy (frame.eth.h_dest, to.addr (), ETH_ALEN);
            ::memcpy (frame.eth.h_source, _hardware.addr (), ETH_ALEN);
            frame.eth.h_proto = htons (ETH_P_IP);
 
            struct iovec iov[2];
            iov[0].iov_base = &frame;
            iov[0].iov_len = sizeof (frame);
            iov[1].iov_base = const_cast<char*> (data);
            iov[1].iov_len = size;
 
            struct msghdr message = {};
            message.msg_iov = iov;
            message.msg_iovlen = 2;
 
            if (::sendmsg (_socket.handle (), &message, 0) == -1)
            {
                // LCOV_EXCL_START
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
                // LCOV_EXCL_STOP
            }
 
            return 0;
        }
 
        ssize_t receive (char* data, size_t maxSize, MacAddress& from, MacAddress& to) noexcept
        {
            Frame frame;
 
            struct iovec iov[2];
            iov[0].iov_base = &frame;
            iov[0].iov_len = sizeof (frame);
            iov[1].iov_base = data;
            iov[1].iov_len = maxSize;
 
            struct msghdr message = {};
            message.msg_iov = iov;
            message.msg_iovlen = 2;
 
            ssize_t size = ::recvmsg (_socket.handle (), &message, 0);
            if (size == -1)
            {
                // LCOV_EXCL_START
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
                // LCOV_EXCL_STOP
            }
 
            if (message.msg_flags & MSG_TRUNC)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::MessageTooLong);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            if (size < static_cast<ssize_t> (sizeof (Frame) + DhcpMessage::headerSize))
            {
                return -1;
            }
 
            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 -1;
            }
 
            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 -1;
            }
 
            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 -1;
            }
 
            const size_t datagram = ntohs (frame.udp.len);
            const size_t available = static_cast<size_t> (size) - sizeof (frame.eth) - sizeof (frame.ip);
 
            if ((datagram < sizeof (frame.udp)) || (datagram > available))
            {
                return -1;
            }
 
            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, data, payloadSize))
                {
                    return -1;
                }
            }
 
            from = MacAddress (frame.eth.h_source, ETH_ALEN);
            to = MacAddress (frame.eth.h_dest, ETH_ALEN);
 
            return static_cast<ssize_t> (payloadSize);
        }
 
        Socket _socket;
 
        DhcpMessage _message;
 
        std::unique_ptr<char[]> _buffer;
 
        const std::string _interface;
 
        const MacAddress _hardware;
 
        Reactor& _reactor;
    };
 
    template <class Protocol>
    class BasicDhcpClient final : protected BasicDhcp<Protocol>
    {
    public:
        using BasicDhcp<Protocol>::hardware;
        using BasicDhcp<Protocol>::interface;
 
        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");
            }
 
            this->attach ();
        }
 
        ~BasicDhcpClient ()
        {
            this->detach ();
        }
 
        DhcpPacket compose (uint8_t type) const
        {
            DhcpPacket packet;
 
            packet.op = DhcpMessage::BootRequest;
            packet.id = randomize<uint32_t> ();
            packet.hardware = 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;
        }
 
        int exchange (DhcpPacket& request, DhcpPacket& answer, const IpAddress& destination, uint8_t expected,
                      std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            if (this->_reactor.isReactorThread ())
            {
                lastError = std::make_error_code (std::errc::resource_deadlock_would_occur);
                return -1;
            }
 
            char payload[Protocol::maxMsgSize];
            ssize_t size = this->_message.serialize (request, payload, sizeof (payload));
            if (size == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            ScopedLock<Mutex> lock (_syncMutex);
 
            _reason.clear ();
 
            PendingRequest pending;
            pending.answer = &answer;
 
            if (!_pending.emplace (request.id, &pending).second)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::InUse);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            if (this->send (payload, static_cast<size_t> (size), request.dest, request.client, destination) == -1)
            {
                // LCOV_EXCL_START
                _pending.erase (request.id);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            bool answered = pending.cond.timedWait (lock, timeout, [&pending] {
                return pending.done;
            });
 
            _pending.erase (request.id);
 
            if (!answered)
            {
                lastError = make_error_code (Errc::TimedOut);
                return -1;
            }
 
            const uint8_t* type = answer.options.getIf<uint8_t> (DhcpOption::DhcpMessageType);
            if (type == nullptr)
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return -1;
            }
 
            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 -1;
            }
 
            if (*type != expected)
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return -1;
            }
 
            return 0;
        }
 
        std::string reason () const
        {
            ScopedLock<Mutex> lock (_syncMutex);
 
            return _reason;
        }
 
        int discover (DhcpPacket& offer, const IpAddress& wants = IpAddress::ipv4Wildcard,
                      std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            DhcpPacket out = compose (DhcpMessage::Discover);
 
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
 
            if (!wants.isWildcard ())
            {
                out.options.insert (DhcpOption::RequestedIpAddress, wants);
            }
 
            return exchange (out, offer, IpAddress::ipv4Broadcast, DhcpMessage::Offer, timeout);
        }
 
        int request (DhcpPacket& ack, const IpAddress& wants, const IpAddress& server,
                     std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            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, ack, IpAddress::ipv4Broadcast, DhcpMessage::Ack, timeout);
        }
 
        int renew (DhcpPacket& ack, const IpAddress& client, const IpAddress& server,
                   std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            if (this->_reactor.isReactorThread ())
            {
                lastError = std::make_error_code (std::errc::resource_deadlock_would_occur);
                return -1;
            }
 
            MacAddress mac = Arp::get (interface (), server, timeout);
            if (mac.isWildcard ())
            {
                return -1;
            }
 
            DhcpPacket out = compose (DhcpMessage::Request);
 
            out.dest = mac;
            out.client = client;
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
 
            return exchange (out, ack, server, DhcpMessage::Ack, timeout);
        }
 
        int inform (DhcpPacket& ack, const IpAddress& client,
                    std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            DhcpPacket out = compose (DhcpMessage::Inform);
 
            out.client = client;
            out.options.insert (DhcpOption::ParameterRequestList, _defaultParams);
 
            return exchange (out, ack, IpAddress::ipv4Broadcast, DhcpMessage::Ack, timeout);
        }
 
        int release (const IpAddress& client, const IpAddress& server,
                     std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            if (this->_reactor.isReactorThread ())
            {
                lastError = std::make_error_code (std::errc::resource_deadlock_would_occur);
                return -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);
 
            char payload[Protocol::maxMsgSize];
            ssize_t size = this->_message.serialize (out, payload, sizeof (payload));
            if (size == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            return this->send (payload, static_cast<size_t> (size), out.dest, client, server);
        }
 
        int decline (const IpAddress& address, const IpAddress& server, const std::string& message = {}) noexcept
        {
            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);
            }
 
            char payload[Protocol::maxMsgSize];
            ssize_t size = this->_message.serialize (out, payload, sizeof (payload));
            if (size == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            return this->send (payload, static_cast<size_t> (size), out.dest, IpAddress::ipv4Wildcard,
                               IpAddress::ipv4Broadcast);
        }
 
    private:
        void onReadable ([[maybe_unused]] int fd) override final
        {
            MacAddress from, to;
            ssize_t size = this->receive (this->_buffer.get (), Protocol::maxMsgSize, from, to);
            if (size == -1)
            {
                return;
            }
 
            DhcpPacket packet;
            if ((this->_message.deserialize (packet, this->_buffer.get (), static_cast<size_t> (size)) == -1) ||
                (packet.op != DhcpMessage::BootReply))
            {
                return;
            }
 
            packet.src = from;
            packet.dest = to;
 
            ScopedLock<Mutex> lock (_syncMutex);
 
            auto it = _pending.find (packet.id);
            if ((it != _pending.end ()) && !it->second->done)
            {
                *it->second->answer = std::move (packet);
                it->second->done = true;
                it->second->cond.signal ();
            }
        }
 
        struct PendingRequest
        {
            Condition cond;
 
            DhcpPacket* answer = nullptr;
 
            bool done = false;
        };
 
        static const ByteList _defaultParams;
 
        std::unordered_map<uint32_t, 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 final : protected BasicDhcp<Protocol>
    {
    public:
        using BasicDhcp<Protocol>::hardware;
        using BasicDhcp<Protocol>::interface;
 
        using RequestNotify = Function<void (DhcpMessage::MessageType type, const DhcpPacket& request)>;
 
        BasicDhcpServer () = delete;
 
        explicit BasicDhcpServer (const std::string& interface, Reactor& reactor = ReactorThread::reactor ())
        : BasicDhcp<Protocol> (interface, reactor)
        {
            this->attach ();
        }
 
        ~BasicDhcpServer ()
        {
            this->detach ();
        }
 
        int offer (const DhcpPacket& request, const IpAddress& address, const DhcpOption& options = {}) noexcept
        {
            return reply (request, DhcpMessage::Offer, address, options);
        }
 
        int ack (const DhcpPacket& request, const IpAddress& address, const DhcpOption& options = {}) noexcept
        {
            return reply (request, DhcpMessage::Ack, address, options);
        }
 
        int nak (const DhcpPacket& request, const std::string& message = {}) noexcept
        {
            DhcpOption options;
 
            if (!message.empty ())
            {
                options.insert (DhcpOption::Message, message);
            }
 
            return reply (request, DhcpMessage::Nak, IpAddress::ipv4Wildcard, options);
        }
 
        int setRequestListener (RequestNotify cb) noexcept
        {
            bool busy = false;
 
            Reactor::InvokeHandler fn = [this, &cb, &busy] () {
                busy = _calling || _listener;
                if (!busy)
                {
                    _listener = std::move (cb);
                }
            };
 
            if (this->_reactor.invoke (&fn) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (busy)
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            return 0;
        }
 
        int unsetRequestListener () noexcept
        {
            Reactor::InvokeHandler fn = [this] () {
                _listener = nullptr;
                _calling = false;
            };
 
            return this->_reactor.invoke (&fn);
        }
 
    private:
        void onReadable ([[maybe_unused]] int fd) override final
        {
            MacAddress from, to;
            ssize_t size = this->receive (this->_buffer.get (), Protocol::maxMsgSize, from, to);
            if (size == -1)
            {
                return;
            }
 
            DhcpPacket packet;
            if ((this->_message.deserialize (packet, this->_buffer.get (), static_cast<size_t> (size)) == -1) ||
                (packet.op != DhcpMessage::BootRequest))
            {
                return;
            }
 
            packet.src = from;
            packet.dest = to;
 
            const uint8_t* type = packet.options.getIf<uint8_t> (DhcpOption::DhcpMessageType);
            if (type == nullptr)
            {
                return;
            }
 
            if (_listener)
            {
                RequestNotify listener = std::move (_listener);
 
                _calling = true;
                listener (static_cast<DhcpMessage::MessageType> (*type), packet);
 
                if (_calling)
                {
                    _listener = std::move (listener);
                    _calling = false;
                }
            }
        }
 
        int reply (const DhcpPacket& request, uint8_t type, const IpAddress& address,
                   const DhcpOption& options) noexcept
        {
            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.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;
 
            char payload[Protocol::maxMsgSize];
            ssize_t size = this->_message.serialize (out, payload, sizeof (payload));
            if (size == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            return this->send (payload, static_cast<size_t> (size), out.dest, server,
                               broadcast ? IpAddress::ipv4Broadcast : unicast);
        }
 
        RequestNotify _listener;
 
        bool _calling = false;
    };
}
 
#endif