arp.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_ARP_HPP
#define JOIN_FABRIC_ARP_HPP
 
// libjoin.
#include <join/neighbor_manager.hpp>
#include <join/mac_address.hpp>
#include <join/raw_socket.hpp>
#include <join/condition.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 EventHandler
    {
    public:
        Arp () = delete;
 
        Arp (const std::string& interface, NeighborManager& neighbors = NeighborManager::instance ());
 
        Arp (const Arp& other) = delete;
 
        Arp (Arp&& other) = delete;
 
        Arp& operator= (const Arp& other) = delete;
 
        Arp& operator= (Arp&& other) = delete;
 
        ~Arp ();
 
        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 (_reactor.isReactorThread ())
            {
                lastError = std::make_error_code (std::errc::resource_deadlock_would_occur);
                return {};
            }
 
            if (ip.family () != AF_INET)
            {
                lastError = make_error_code (Errc::InvalidParam);
                return {};
            }
 
            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);
 
            uint32_t tip;
            ::memcpy (&tip, &out.arp.ar_tip, sizeof (tip));
            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 (_socket.write (reinterpret_cast<const char*> (&out), sizeof (Packet)) == -1)
            {
                // LCOV_EXCL_START
                _pending.erase (inserted.first);
                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;
        }
 
        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;
        };
 
        void onReadable (int fd) noexcept override final;
 
        static constexpr size_t _bufferSize = 4096;
 
        struct PendingRequest
        {
            Condition cond;
            MacAddress mac;
        };
 
        std::unordered_map<uint32_t, std::unique_ptr<PendingRequest>> _pending;
 
        Mutex _syncMutex;
 
        Raw::Socket _socket;
 
        const std::string _interface;
 
        uint32_t _index = 0;
 
        NeighborManager& _neighbors;
 
        Reactor& _reactor;
    };
}
 
#endif