arp.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_ARP_HPP
#define JOIN_FABRIC_ARP_HPP
 
// libjoin.
#include <join/neighbormanager.hpp>
#include <join/macaddress.hpp>
#include <join/condition.hpp>
#include <join/socket.hpp>
 
// C++.
#include <unordered_map>
#include <string>
 
// C.
#include <linux/filter.h>
#include <net/if_arp.h>
#include <net/if.h>
 
namespace join
{
    class Arp : public Raw::Socket
    {
    public:
        Arp () = delete;
 
        Arp (const std::string& interface, NeighborManager* neighbors = nullptr);
 
        Arp (const Arp& other) = delete;
 
        Arp (Arp&& other) = delete;
 
        Arp& operator= (const Arp& other) = delete;
 
        Arp& operator= (Arp&& other) = delete;
 
        ~Arp () = default;
 
        template <typename Rep, typename Period>
        MacAddress get (const IpAddress& ip, std::chrono::duration<Rep, Period> timeout)
        {
            if (ip.family () != AF_INET)
            {
                lastError = make_error_code (Errc::InvalidParam);
                return {};
            }
 
            if (ip == IpAddress::ipv4Address (_interface))
            {
                return MacAddress::address (_interface);
            }
 
            MacAddress mac = cache (ip);
 
            return mac.isWildcard () ? request (ip, timeout) : mac;
        }
 
        MacAddress get (const IpAddress& ip)
        {
            return get (ip, std::chrono::seconds (5));
        }
 
        template <typename Rep, typename Period>
        static MacAddress get (const std::string& interface, const IpAddress& ip,
                               std::chrono::duration<Rep, Period> timeout)
        {
            return Arp (interface).get (ip, timeout);
        }
 
        static MacAddress get (const std::string& interface, const IpAddress& ip)
        {
            return get (interface, ip, std::chrono::seconds (5));
        }
 
        template <typename Rep, typename Period>
        MacAddress request (const IpAddress& ip, std::chrono::duration<Rep, Period> timeout)
        {
            if (ip.family () != AF_INET)
            {
                lastError = make_error_code (Errc::InvalidParam);
                return {};
            }
 
            if (bind (_interface) == -1 || setOption (Raw::Socket::Broadcast, 1) == -1)
            {
                return {};
            }
 
            // accept only ARP replies.
            struct sock_filter code[] = {
                {0x28, 0, 0, 0x0000000c}, {0x15, 0, 3, 0x00000806}, {0x28, 0, 0, 0x00000014},
                {0x15, 0, 1, 0x00000002}, {0x6, 0, 0, 0x00040000},  {0x6, 0, 0, 0x00000000},
            };
 
            struct sock_fprog bpf;
            bpf.len    = 6;
            bpf.filter = code;
 
            // best effort, validation is done in onReceive anyway.
            ::setsockopt (handle (), SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof (bpf));
 
            Packet out              = {};
            const MacAddress srcMac = MacAddress::address (_interface);
            const IpAddress srcIp   = IpAddress::ipv4Address (_interface);
 
            ::memcpy (out.eth.h_dest, MacAddress::broadcast.addr (), ETH_ALEN);
            ::memcpy (out.eth.h_source, srcMac.addr (), ETH_ALEN);
            out.eth.h_proto = ::htons (ETH_P_ARP);
 
            out.arp.ar_hrd = ::htons (ARPHRD_ETHER);
            out.arp.ar_pro = ::htons (ETH_P_IP);
            out.arp.ar_hln = ETH_ALEN;
            out.arp.ar_pln = 4;
            out.arp.ar_op  = ::htons (ARPOP_REQUEST);
            ::memcpy (out.arp.ar_sha, srcMac.addr (), ETH_ALEN);
            ::memcpy (&out.arp.ar_sip, srcIp.addr (), sizeof (uint32_t));
            ::memcpy (out.arp.ar_tha, MacAddress::wildcard.addr (), ETH_ALEN);
            ::memcpy (&out.arp.ar_tip, ip.addr (), sizeof (uint32_t));
 
            ScopedLock<Mutex> lock (_syncMutex);
 
            if (write (reinterpret_cast<const char*> (&out), sizeof (Packet)) == -1)
            {
                close ();
                return {};
            }
 
            _reactor->addHandler (handle (), this);
            MacAddress mac = waitResponse (lock, out.arp.ar_tip, timeout);
            _reactor->delHandler (handle ());
 
            close ();
            return mac;
        }
 
        MacAddress request (const IpAddress& ip)
        {
            return request (ip, std::chrono::seconds (5));
        }
 
        template <typename Rep, typename Period>
        static MacAddress request (const std::string& interface, const IpAddress& ip,
                                   std::chrono::duration<Rep, Period> timeout)
        {
            return Arp (interface).request (ip, timeout);
        }
 
        static MacAddress request (const std::string& interface, const IpAddress& ip)
        {
            return request (interface, ip, std::chrono::seconds (5));
        }
 
        int add (const MacAddress& mac, const IpAddress& ip);
 
        static int add (const std::string& interface, const MacAddress& mac, const IpAddress& ip);
 
        int remove (const IpAddress& ip);
 
        static int remove (const std::string& interface, const IpAddress& ip);
 
        MacAddress cache (const IpAddress& ip);
 
        static MacAddress cache (const std::string& interface, const IpAddress& ip);
 
    private:
        struct __attribute__ ((packed)) ArpPacket
        {
            uint16_t ar_hrd;
            uint16_t ar_pro;
            uint8_t ar_hln;
            uint8_t ar_pln;
            uint16_t ar_op;
            uint8_t ar_sha[ETH_ALEN];
            uint32_t ar_sip;
            uint8_t ar_tha[ETH_ALEN];
            uint32_t ar_tip;
        };
 
        struct __attribute__ ((packed)) Packet
        {
            struct ethhdr eth;
            ArpPacket arp;
        };
 
        template <typename Rep, typename Period>
        MacAddress waitResponse (ScopedLock<Mutex>& lock, uint32_t tip, std::chrono::duration<Rep, Period> timeout)
        {
            auto inserted = _pending.emplace (tip, std::make_unique<PendingRequest> ());
            if (!inserted.second)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::OperationFailed);
                return {};
                // LCOV_EXCL_STOP
            }
 
            if (!inserted.first->second->cond.timedWait (lock, timeout))
            {
                _pending.erase (inserted.first);
                lastError = std::make_error_code (std::errc::no_such_device_or_address);
                return {};
            }
 
            MacAddress mac = inserted.first->second->mac;
            _pending.erase (inserted.first);
 
            return mac;
        }
 
        void onReceive (int fd) noexcept override;
 
        static constexpr size_t _bufferSize = 4096;
 
        struct PendingRequest
        {
            Condition cond;
            MacAddress mac;
        };
 
        std::unordered_map<uint32_t, std::unique_ptr<PendingRequest>> _pending;
 
        Mutex _syncMutex;
 
        const std::string _interface;
 
        NeighborManager* _neighbors = nullptr;
 
        Reactor* const _reactor = nullptr;
    };
}
 
#endif