ndp.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_NDP_HPP
#define JOIN_FABRIC_NDP_HPP
 
// libjoin.
#include <join/datagram_socket.hpp>
#include <join/ndp_protocol.hpp>
#include <join/ndp_message.hpp>
#include <join/condition.hpp>
#include <join/function.hpp>
#include <join/reactor.hpp>
#include <join/error.hpp>
 
// C++.
#include <system_error>
#include <algorithm>
#include <chrono>
#include <memory>
#include <string>
#include <vector>
 
// C.
#include <netinet/icmp6.h>
#include <net/if.h>
 
namespace join
{
    template <class Protocol>
    class BasicNdp : public EventHandler
    {
    public:
        using Socket = typename Protocol::Socket;
        using Endpoint = typename Protocol::Endpoint;
 
        using NeighborSolicitationNotify = Function<void (const NeighborSolicitation& solicitation)>;
 
        using NeighborAdvertisementNotify = Function<void (const NeighborAdvertisement& advert)>;
 
        BasicNdp () = delete;
 
        BasicNdp (const std::string& interface, uint8_t filter, const IpAddress& group, Reactor& reactor)
        : _socket (Protocol::hopLimit)
        , _buffer (std::make_unique<char[]> (Protocol::maxMsgSize))
        , _interface (interface)
        , _index (lookup (interface))
        , _hardware (MacAddress::address (interface))
        , _reactor (reactor)
        {
            if (_socket.open (Protocol::Transport::v6 ()) == -1)
            {
                throw std::system_error (lastError, "ndp socket open failed");  // LCOV_EXCL_LINE
            }
 
            if (_socket.bindToDevice (_interface) == -1)
            {
                throw std::system_error (lastError, "ndp socket bind to device failed");  // LCOV_EXCL_LINE
            }
 
            int on = 1;
 
            if (::setsockopt (_socket.handle (), IPPROTO_IPV6, IPV6_MULTICAST_IF, &_index, sizeof (_index)) == -1)
            {
                // LCOV_EXCL_START
                throw std::system_error (errno, std::generic_category (), "ndp multicast setup failed");
                // LCOV_EXCL_STOP
            }
 
            if (::setsockopt (_socket.handle (), IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof (on)) == -1)
            {
                // LCOV_EXCL_START
                throw std::system_error (errno, std::generic_category (), "ndp hop limit setup failed");
                // LCOV_EXCL_STOP
            }
 
            if (::setsockopt (_socket.handle (), IPPROTO_IPV6, IPV6_DONTFRAG, &on, sizeof (on)) == -1)
            {
                // LCOV_EXCL_START
                throw std::system_error (errno, std::generic_category (), "ndp dontfrag setup failed");
                // LCOV_EXCL_STOP
            }
 
            ICMP6_FILTER_SETBLOCKALL (&_filter);
 
            if (applyFilter (filter, true) == -1)
            {
                throw std::system_error (lastError, "ndp icmp6 filter setup failed");  // LCOV_EXCL_LINE
            }
 
            if (!group.isWildcard ())
            {
                struct ipv6_mreq mreq = {};
                ::memcpy (&mreq.ipv6mr_multiaddr, group.addr (), group.length ());
                mreq.ipv6mr_interface = _index;
 
                if (::setsockopt (_socket.handle (), IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq, sizeof (mreq)) == -1)
                {
                    // LCOV_EXCL_START
                    throw std::system_error (errno, std::generic_category (), "ndp multicast membership setup failed");
                    // LCOV_EXCL_STOP
                }
            }
        }
 
        BasicNdp (const BasicNdp& other) = delete;
 
        BasicNdp& operator= (const BasicNdp& other) = delete;
 
        BasicNdp (BasicNdp&& other) = delete;
 
        BasicNdp& operator= (BasicNdp&& other) = delete;
 
        virtual ~BasicNdp () = default;
 
        int neighborSolicit (const IpAddress& target, NeighborAdvertisement& advert,
                             std::chrono::milliseconds timeout = std::chrono::seconds (1)) noexcept
        {
            if (_reactor.isReactorThread ())
            {
                lastError = std::make_error_code (std::errc::resource_deadlock_would_occur);
                return -1;
            }
 
            NeighborSolicitation out;
            out.target = target;
            out.link = _hardware;
 
            char payload[NdpMessage::maxNeighborSolicitationSize];
            ssize_t size = _message.serialize (out, payload, sizeof (payload));
            if (size == -1)
            {
                return -1;
            }
 
            struct in6_addr group;
            ::memcpy (&group, IpAddress::ipv6SolicitedNodes.addr (), sizeof (group));
            ::memcpy (&group.s6_addr[13], static_cast<const uint8_t*> (target.addr ()) + 13, 3);
 
            NeighborRequest pending;
            pending.target = IpAddress (target.addr (), target.length ());
            pending.advert = &advert;
 
            Reactor::InvokeHandler addFilter = [this, &pending] () {
                _neighborPending.push_back (&pending);
                applyFilter (NdpMessage::NeighborAdvert, true);
            };
 
            Reactor::InvokeHandler delFilter = [this, &pending] () {
                _neighborPending.erase (std::find (_neighborPending.begin (), _neighborPending.end (), &pending));
                applyFilter (NdpMessage::NeighborAdvert, _neighborAdvertisementListener || !_neighborPending.empty ());
            };
 
            if (_reactor.invoke (&addFilter) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (send (payload, static_cast<size_t> (size), IpAddress (&group, sizeof (group))) == -1)
            {
                // LCOV_EXCL_START
                _reactor.invoke (&delFilter);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            {
                ScopedLock<Mutex> lock (_neighborMutex);
                pending.cond.timedWait (lock, timeout, [&pending] {
                    return pending.done;
                });
            }
 
            _reactor.invoke (&delFilter);
 
            if (!pending.done)
            {
                lastError = make_error_code (Errc::TimedOut);
                return -1;
            }
 
            return 0;
        }
 
        int neighborAdvertise (const NeighborAdvertisement& advert,
                               const IpAddress& destination = IpAddress::ipv6AllNodes) noexcept
        {
            char payload[NdpMessage::maxNeighborAdvertisementSize];
            ssize_t size = _message.serialize (advert, payload, sizeof (payload),
                                               advert.link.isWildcard () ? _hardware : advert.link);
            if (size == -1)
            {
                return -1;
            }
 
            return send (payload, static_cast<size_t> (size), destination);
        }
 
        int neighborAdvertise (const NeighborAdvertisement& advert, const NeighborSolicitation& solicitation) noexcept
        {
            char payload[NdpMessage::maxNeighborAdvertisementSize];
            ssize_t size = _message.serialize (advert, payload, sizeof (payload),
                                               advert.link.isWildcard () ? _hardware : advert.link);
            if (size == -1)
            {
                return -1;
            }
 
            struct nd_neighbor_advert na;
            ::memcpy (&na, payload, sizeof (na));
 
            if (solicitation.src.isWildcard ())
            {
                na.nd_na_flags_reserved &= ~ND_NA_FLAG_SOLICITED;
            }
            else
            {
                na.nd_na_flags_reserved |= ND_NA_FLAG_SOLICITED;
            }
 
            ::memcpy (payload, &na, sizeof (na));
 
            return send (payload, static_cast<size_t> (size),
                         solicitation.src.isWildcard () ? IpAddress::ipv6AllNodes : solicitation.src);
        }
 
        int setNeighborSolicitationListener (NeighborSolicitationNotify cb) noexcept
        {
            bool busy = false;
 
            Reactor::InvokeHandler fn = [this, &cb, &busy] () {
                busy = _neighborSolicitationCalling || _neighborSolicitationListener;
                if (!busy)
                {
                    _neighborSolicitationListener = std::move (cb);
                    applyFilter (NdpMessage::NeighborSolicit, true);
                }
            };
 
            if (_reactor.invoke (&fn) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (busy)
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            return 0;
        }
 
        int unsetNeighborSolicitationListener () noexcept
        {
            Reactor::InvokeHandler fn = [this] () {
                _neighborSolicitationListener = nullptr;
                _neighborSolicitationCalling = false;
                applyFilter (NdpMessage::NeighborSolicit, false);
            };
 
            return _reactor.invoke (&fn);
        }
 
        int setNeighborAdvertisementListener (NeighborAdvertisementNotify cb) noexcept
        {
            bool busy = false;
 
            Reactor::InvokeHandler fn = [this, &cb, &busy] () {
                busy = _neighborAdvertisementCalling || _neighborAdvertisementListener;
                if (!busy)
                {
                    _neighborAdvertisementListener = std::move (cb);
                    applyFilter (NdpMessage::NeighborAdvert, true);
                }
            };
 
            if (_reactor.invoke (&fn) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (busy)
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            return 0;
        }
 
        int unsetNeighborAdvertisementListener () noexcept
        {
            Reactor::InvokeHandler fn = [this] () {
                _neighborAdvertisementListener = nullptr;
                _neighborAdvertisementCalling = false;
                applyFilter (NdpMessage::NeighborAdvert, !_neighborPending.empty ());
            };
 
            return _reactor.invoke (&fn);
        }
 
        const std::string& interface () const noexcept
        {
            return _interface;
        }
 
        unsigned int index () const noexcept
        {
            return _index;
        }
 
        const MacAddress& hardware () const noexcept
        {
            return _hardware;
        }
 
    protected:
        void attach ()
        {
            if (_reactor.addHandler (_socket.handle (), this) == -1)
            {
                throw std::system_error (lastError, "ndp reactor registration failed");  // LCOV_EXCL_LINE
            }
        }
 
        void detach () noexcept
        {
            _reactor.delHandler (_socket.handle ());
        }
 
        int applyFilter (uint8_t type, bool pass) noexcept
        {
            if (ICMP6_FILTER_WILLPASS (type, &_filter) == pass)
            {
                return 0;
            }
 
            struct icmp6_filter filter = _filter;
 
            if (pass)
            {
                ICMP6_FILTER_SETPASS (type, &filter);
            }
            else
            {
                ICMP6_FILTER_SETBLOCK (type, &filter);
            }
 
            if (::setsockopt (_socket.handle (), IPPROTO_ICMPV6, ICMP6_FILTER, &filter, sizeof (filter)) == -1)
            {
                // LCOV_EXCL_START
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
                // LCOV_EXCL_STOP
            }
 
            _filter = filter;
 
            return 0;
        }
 
        int send (const char* data, size_t size, const IpAddress& destination)
        {
            if (destination.family () != AF_INET6)
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            if (size > Protocol::maxMsgSize)
            {
                // LCOV_EXCL_START
                lastError = make_error_code (Errc::MessageTooLong);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            Endpoint endpoint (IpAddress (destination.addr (), destination.length (), _index));
 
            return (_socket.writeTo (data, size, endpoint) == -1) ? -1 : 0;
        }
 
        ssize_t receive (char* data, size_t maxSize, IpAddress& from)
        {
            Endpoint endpoint;
            char control[CMSG_SPACE (sizeof (int))];
            size_t controlSize = sizeof (control);
 
            ssize_t size = _socket.readFrom (data, maxSize, &endpoint, control, &controlSize);
            if (size <= 0)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            struct msghdr msg = {};
            msg.msg_control = control;
            msg.msg_controllen = controlSize;
 
            int hop = 0;
 
            for (struct cmsghdr* cmsg = CMSG_FIRSTHDR (&msg); cmsg != nullptr; cmsg = CMSG_NXTHDR (&msg, cmsg))
            {
                if ((cmsg->cmsg_level == IPPROTO_IPV6) && (cmsg->cmsg_type == IPV6_HOPLIMIT))
                {
                    ::memcpy (&hop, CMSG_DATA (cmsg), sizeof (hop));
                }
            }
 
            if (hop != Protocol::hopLimit)
            {
                return -1;
            }
 
            from = endpoint.ip ();
 
            return size;
        }
 
        bool onNeighborMessage (size_t size, const IpAddress& from) noexcept
        {
            const uint8_t type = static_cast<uint8_t> (_buffer[0]);
 
            if (type == NdpMessage::NeighborSolicit)
            {
                if (!_neighborSolicitationListener)
                {
                    return true;  // LCOV_EXCL_LINE
                }
 
                NeighborSolicitation solicitation;
                if ((_message.deserialize (solicitation, _buffer.get (), size) == 0) &&
                    (!from.isWildcard () || solicitation.link.isWildcard ()))
                {
                    solicitation.src = from;
 
                    NeighborSolicitationNotify listener = std::move (_neighborSolicitationListener);
 
                    _neighborSolicitationCalling = true;
                    listener (solicitation);
 
                    if (_neighborSolicitationCalling)
                    {
                        _neighborSolicitationListener = std::move (listener);
                        _neighborSolicitationCalling = false;
                    }
                }
 
                return true;
            }
 
            if (type != NdpMessage::NeighborAdvert)
            {
                return false;
            }
 
            if (!_neighborAdvertisementListener && _neighborPending.empty ())
            {
                return true;  // LCOV_EXCL_LINE
            }
 
            NeighborAdvertisement advert;
            if (_message.deserialize (advert, _buffer.get (), size) == 0)
            {
                advert.src = from;
 
                if (_neighborAdvertisementListener)
                {
                    NeighborAdvertisementNotify listener = std::move (_neighborAdvertisementListener);
 
                    _neighborAdvertisementCalling = true;
                    listener (advert);
 
                    if (_neighborAdvertisementCalling)
                    {
                        _neighborAdvertisementListener = std::move (listener);
                        _neighborAdvertisementCalling = false;
                    }
                }
 
                if (!_neighborPending.empty ())
                {
                    ScopedLock<Mutex> lock (_neighborMutex);
 
                    for (NeighborRequest* pending : _neighborPending)
                    {
                        if (!pending->done && !advert.link.isWildcard () && (pending->target == advert.target))
                        {
                            *pending->advert = advert;
                            pending->done = true;
                            pending->cond.signal ();
                        }
                    }
                }
            }
 
            return true;
        }
 
        static unsigned int lookup (const std::string& interface)
        {
            unsigned int index = ::if_nametoindex (interface.c_str ());
            if (index == 0)
            {
                throw std::system_error (errno, std::generic_category (), "ndp interface lookup failed");
            }
 
            return index;
        }
 
        Socket _socket;
 
        NdpMessage _message;
 
        std::unique_ptr<char[]> _buffer;
 
        const std::string _interface;
 
        const unsigned int _index;
 
        const MacAddress _hardware;
 
        Reactor& _reactor;
 
        struct icmp6_filter _filter;
 
        struct NeighborRequest
        {
            Condition cond;
 
            IpAddress target{AF_INET6};
 
            NeighborAdvertisement* advert = nullptr;
 
            bool done = false;
        };
 
        std::vector<NeighborRequest*> _neighborPending;
 
        Mutex _neighborMutex;
 
        NeighborSolicitationNotify _neighborSolicitationListener;
 
        bool _neighborSolicitationCalling = false;
 
        NeighborAdvertisementNotify _neighborAdvertisementListener;
 
        bool _neighborAdvertisementCalling = false;
    };
 
    template <class Protocol>
    class BasicNdpClient final : protected BasicNdp<Protocol>
    {
    public:
        using BasicNdp<Protocol>::interface;
        using BasicNdp<Protocol>::hardware;
        using BasicNdp<Protocol>::index;
        using BasicNdp<Protocol>::neighborSolicit;
        using BasicNdp<Protocol>::neighborAdvertise;
        using BasicNdp<Protocol>::setNeighborSolicitationListener;
        using BasicNdp<Protocol>::unsetNeighborSolicitationListener;
        using BasicNdp<Protocol>::setNeighborAdvertisementListener;
        using BasicNdp<Protocol>::unsetNeighborAdvertisementListener;
        using typename BasicNdp<Protocol>::NeighborSolicitationNotify;
        using typename BasicNdp<Protocol>::NeighborAdvertisementNotify;
 
        using RouterAdvertisementNotify = Function<void (const RouterAdvertisement& advert)>;
 
        BasicNdpClient () = delete;
 
        explicit BasicNdpClient (const std::string& interface, Reactor& reactor = ReactorThread::reactor ())
        : BasicNdp<Protocol> (interface, NdpMessage::RouterAdvert, IpAddress::ipv6Wildcard, reactor)
        {
            this->attach ();
        }
 
        ~BasicNdpClient ()
        {
            this->detach ();
        }
 
        int routerSolicit () noexcept
        {
            RouterSolicitation out;
            out.link = hardware ();
 
            char payload[NdpMessage::maxRouterSolicitationSize];
            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), IpAddress::ipv6Routers);
        }
 
        int routerSolicit (RouterAdvertisement& advert,
                           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;
            }
 
            RouterRequest pending;
            pending.advert = &advert;
 
            Reactor::InvokeHandler addRequest = [this, &pending] () {
                _pending.push_back (&pending);
            };
 
            Reactor::InvokeHandler delRequest = [this, &pending] () {
                _pending.erase (std::find (_pending.begin (), _pending.end (), &pending));
            };
 
            if (this->_reactor.invoke (&addRequest) == -1)
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (routerSolicit () == -1)
            {
                // LCOV_EXCL_START
                this->_reactor.invoke (&delRequest);
                return -1;
                // LCOV_EXCL_STOP
            }
 
            {
                ScopedLock<Mutex> lock (_routerMutex);
                pending.cond.timedWait (lock, timeout, [&pending] {
                    return pending.done;
                });
            }
 
            this->_reactor.invoke (&delRequest);
 
            if (!pending.done)
            {
                lastError = make_error_code (Errc::TimedOut);
                return -1;
            }
 
            return 0;
        }
 
        int setRouterAdvertisementListener (RouterAdvertisementNotify cb) noexcept
        {
            bool busy = false;
 
            Reactor::InvokeHandler fn = [this, &cb, &busy] () {
                busy = _routerAdvertisementCalling || _routerAdvertisementListener;
                if (!busy)
                {
                    _routerAdvertisementListener = 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 unsetRouterAdvertisementListener () noexcept
        {
            Reactor::InvokeHandler fn = [this] () {
                _routerAdvertisementListener = nullptr;
                _routerAdvertisementCalling = false;
            };
 
            return this->_reactor.invoke (&fn);
        }
 
    private:
        void onReadable ([[maybe_unused]] int fd) override final
        {
            IpAddress from;
            ssize_t size = this->receive (this->_buffer.get (), Protocol::maxMsgSize, from);
            if (size == -1)
            {
                return;
            }
 
            if (this->onNeighborMessage (static_cast<size_t> (size), from))
            {
                return;
            }
 
            if (!from.isLinkLocal ())
            {
                return;
            }
 
            RouterAdvertisement advert;
            if (this->_message.deserialize (advert, this->_buffer.get (), static_cast<size_t> (size)) == -1)
            {
                return;
            }
 
            advert.src = from;
 
            if (_routerAdvertisementListener)
            {
                RouterAdvertisementNotify listener = std::move (_routerAdvertisementListener);
 
                _routerAdvertisementCalling = true;
                listener (advert);
 
                if (_routerAdvertisementCalling)
                {
                    _routerAdvertisementListener = std::move (listener);
                    _routerAdvertisementCalling = false;
                }
            }
 
            if (!_pending.empty ())
            {
                ScopedLock<Mutex> lock (_routerMutex);
 
                for (RouterRequest* pending : _pending)
                {
                    if (!pending->done)
                    {
                        *pending->advert = advert;
                        pending->done = true;
                        pending->cond.signal ();
                    }
                }
            }
        }
 
        struct RouterRequest
        {
            Condition cond;
 
            RouterAdvertisement* advert = nullptr;
 
            bool done = false;
        };
 
        std::vector<RouterRequest*> _pending;
 
        Mutex _routerMutex;
 
        RouterAdvertisementNotify _routerAdvertisementListener;
 
        bool _routerAdvertisementCalling = false;
    };
 
    template <class Protocol>
    class BasicNdpServer final : protected BasicNdp<Protocol>
    {
    public:
        using BasicNdp<Protocol>::interface;
        using BasicNdp<Protocol>::hardware;
        using BasicNdp<Protocol>::index;
        using BasicNdp<Protocol>::neighborSolicit;
        using BasicNdp<Protocol>::neighborAdvertise;
        using BasicNdp<Protocol>::setNeighborSolicitationListener;
        using BasicNdp<Protocol>::unsetNeighborSolicitationListener;
        using BasicNdp<Protocol>::setNeighborAdvertisementListener;
        using BasicNdp<Protocol>::unsetNeighborAdvertisementListener;
        using typename BasicNdp<Protocol>::NeighborSolicitationNotify;
        using typename BasicNdp<Protocol>::NeighborAdvertisementNotify;
 
        using RouterSolicitationNotify = Function<void (const RouterSolicitation& solicitation)>;
 
        BasicNdpServer () = delete;
 
        explicit BasicNdpServer (const std::string& interface, Reactor& reactor = ReactorThread::reactor ())
        : BasicNdp<Protocol> (interface, NdpMessage::RouterSolicit, IpAddress::ipv6Routers, reactor)
        {
            this->attach ();
        }
 
        ~BasicNdpServer ()
        {
            this->detach ();
        }
 
        int setRouterSolicitationListener (RouterSolicitationNotify cb) noexcept
        {
            bool busy = false;
 
            Reactor::InvokeHandler fn = [this, &cb, &busy] () {
                busy = _routerSolicitationCalling || _routerSolicitationListener;
                if (!busy)
                {
                    _routerSolicitationListener = 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 unsetRouterSolicitationListener () noexcept
        {
            Reactor::InvokeHandler fn = [this] () {
                _routerSolicitationListener = nullptr;
                _routerSolicitationCalling = false;
            };
 
            return this->_reactor.invoke (&fn);
        }
 
        int routerAdvertise (const RouterAdvertisement& advert,
                             const IpAddress& destination = IpAddress::ipv6AllNodes) noexcept
        {
            char payload[Protocol::maxMsgSize];
            ssize_t size = this->_message.serialize (advert, payload, sizeof (payload),
                                                     advert.link.isWildcard () ? hardware () : advert.link);
            if (size == -1)
            {
                return -1;
            }
 
            return this->send (payload, static_cast<size_t> (size), destination);
        }
 
        int routerAdvertise (const RouterAdvertisement& advert, const RouterSolicitation& solicitation) noexcept
        {
            return routerAdvertise (advert,
                                    solicitation.src.isWildcard () ? IpAddress::ipv6AllNodes : solicitation.src);
        }
 
    private:
        void onReadable ([[maybe_unused]] int fd) override final
        {
            IpAddress from;
            ssize_t size = this->receive (this->_buffer.get (), Protocol::maxMsgSize, from);
            if (size == -1)
            {
                return;
            }
 
            if (this->onNeighborMessage (static_cast<size_t> (size), from))
            {
                return;
            }
 
            RouterSolicitation solicitation;
            if (this->_message.deserialize (solicitation, this->_buffer.get (), static_cast<size_t> (size)) == -1)
            {
                return;
            }
 
            if (from.isWildcard () && !solicitation.link.isWildcard ())
            {
                return;
            }
 
            solicitation.src = from;
 
            if (_routerSolicitationListener)
            {
                RouterSolicitationNotify listener = std::move (_routerSolicitationListener);
 
                _routerSolicitationCalling = true;
                listener (solicitation);
 
                if (_routerSolicitationCalling)
                {
                    _routerSolicitationListener = std::move (listener);
                    _routerSolicitationCalling = false;
                }
            }
        }
 
        RouterSolicitationNotify _routerSolicitationListener;
 
        bool _routerSolicitationCalling = false;
    };
}
 
#endif