ndp_message.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_NDP_MESSAGE_HPP
#define JOIN_FABRIC_NDP_MESSAGE_HPP
 
// libjoin.
#include <join/mac_address.hpp>
#include <join/utils.hpp>
#include <join/ip_address.hpp>
#include <join/error.hpp>
 
// C++.
#include <vector>
 
// C.
#include <netinet/icmp6.h>
#include <net/ethernet.h>
#include <netinet/in.h>
#include <cstring>
 
namespace join
{
    struct NdpPrefix
    {
        IpAddress prefix{AF_INET6};
 
        uint8_t length = 64;
 
        uint8_t flags = ND_OPT_PI_FLAG_ONLINK | ND_OPT_PI_FLAG_AUTO;
 
        uint32_t valid = 2592000;
 
        uint32_t preferred = 604800;
    };
 
    struct NdpRdnss
    {
        uint32_t lifetime = 1800;
 
        std::vector<IpAddress> servers;
    };
 
    struct RouterSolicitation
    {
        IpAddress src{AF_INET6};
 
        MacAddress link;
    };
 
    struct RouterAdvertisement
    {
        IpAddress src{AF_INET6};
 
        uint8_t hopLimit = 0;
 
        uint8_t flags = 0;
 
        uint16_t lifetime = 0;
 
        uint32_t reachable = 0;
 
        uint32_t retransmit = 0;
 
        MacAddress link;
 
        uint32_t mtu = 0;
 
        std::vector<NdpPrefix> prefixes;
 
        std::vector<NdpRdnss> rdnss;
    };
 
    struct NeighborSolicitation
    {
        IpAddress src{AF_INET6};
 
        IpAddress target{AF_INET6};
 
        MacAddress link;
    };
 
    struct NeighborAdvertisement
    {
        IpAddress src{AF_INET6};
 
        uint32_t flags = 0;
 
        IpAddress target{AF_INET6};
 
        MacAddress link;
    };
 
    class NdpMessage
    {
    public:
        enum MessageType : uint8_t
        {
            RouterSolicit = ND_ROUTER_SOLICIT,     
            RouterAdvert = ND_ROUTER_ADVERT,       
            NeighborSolicit = ND_NEIGHBOR_SOLICIT, 
            NeighborAdvert = ND_NEIGHBOR_ADVERT,   
        };
 
        enum OptionType : uint8_t
        {
            SourceLinkAddress = ND_OPT_SOURCE_LINKADDR,    
            TargetLinkAddress = ND_OPT_TARGET_LINKADDR,    
            PrefixInformation = ND_OPT_PREFIX_INFORMATION, 
            Mtu = ND_OPT_MTU,                              
            RecursiveDnsServer = 25,                       
        };
 
        ssize_t serialize (const RouterSolicitation& packet, char* data, size_t maxSize) const
        {
            char* cur = data;
            const char* end = data + maxSize;
            bool ok = true;
 
            struct nd_router_solicit rs = {};
            rs.nd_rs_type = RouterSolicit;
            ok &= writeBytes (cur, end, &rs, sizeof (rs));
            ok &= writeLinkAddress (cur, end, packet.link);
 
            return ok ? cur - data : -1;
        }
 
        ssize_t serialize (const RouterAdvertisement& packet, char* data, size_t maxSize) const
        {
            return serialize (packet, data, maxSize, packet.link);
        }
 
        ssize_t serialize (const RouterAdvertisement& packet, char* data, size_t maxSize, const MacAddress& link) const
        {
            for (auto const& prefix : packet.prefixes)
            {
                if ((prefix.prefix.family () != AF_INET6) || (prefix.length > 128))
                {
                    lastError = make_error_code (Errc::InvalidParam);
                    return -1;
                }
            }
 
            for (auto const& rdnss : packet.rdnss)
            {
                if (rdnss.servers.empty ())
                {
                    lastError = make_error_code (Errc::InvalidParam);
                    return -1;
                }
 
                if (rdnss.servers.size () > _maxDnsServers)
                {
                    lastError = make_error_code (Errc::MessageTooLong);
                    return -1;
                }
 
                for (auto const& server : rdnss.servers)
                {
                    if (server.family () != AF_INET6)
                    {
                        lastError = make_error_code (Errc::InvalidParam);
                        return -1;
                    }
                }
            }
 
            char* cur = data;
            const char* end = data + maxSize;
            bool ok = true;
 
            struct nd_router_advert ra = {};
            ra.nd_ra_type = RouterAdvert;
            ra.nd_ra_curhoplimit = packet.hopLimit;
            ra.nd_ra_flags_reserved = packet.flags;
            ra.nd_ra_router_lifetime = htons (packet.lifetime);
            ra.nd_ra_reachable = htonl (packet.reachable);
            ra.nd_ra_retransmit = htonl (packet.retransmit);
            ok &= writeBytes (cur, end, &ra, sizeof (ra));
 
            ok &= writeLinkAddress (cur, end, link);
 
            if (packet.mtu)
            {
                struct nd_opt_mtu mtu = {};
                mtu.nd_opt_mtu_type = Mtu;
                mtu.nd_opt_mtu_len = sizeof (mtu) >> 3;
                mtu.nd_opt_mtu_mtu = htonl (packet.mtu);
                ok &= writeBytes (cur, end, &mtu, sizeof (mtu));
            }
 
            for (auto const& prefix : packet.prefixes)
            {
                IpAddress masked = prefix.prefix & IpAddress (prefix.length, AF_INET6);
 
                struct nd_opt_prefix_info pi = {};
                pi.nd_opt_pi_type = PrefixInformation;
                pi.nd_opt_pi_len = sizeof (pi) >> 3;
                pi.nd_opt_pi_prefix_len = prefix.length;
                pi.nd_opt_pi_flags_reserved = prefix.flags;
                pi.nd_opt_pi_valid_time = htonl (prefix.valid);
                pi.nd_opt_pi_preferred_time = htonl (prefix.preferred);
                ::memcpy (&pi.nd_opt_pi_prefix, masked.addr (), sizeof (pi.nd_opt_pi_prefix));
                ok &= writeBytes (cur, end, &pi, sizeof (pi));
            }
 
            for (auto const& rdnss : packet.rdnss)
            {
                RdnssHeader header = {};
                header.type = RecursiveDnsServer;
                header.len = static_cast<uint8_t> (1 + (rdnss.servers.size () * 2));
                header.lifetime = htonl (rdnss.lifetime);
                ok &= writeBytes (cur, end, &header, sizeof (header));
 
                for (auto const& server : rdnss.servers)
                {
                    ok &= writeBytes (cur, end, server.addr (), sizeof (struct in6_addr));
                }
            }
 
            return ok ? cur - data : -1;
        }
 
        ssize_t serialize (const NeighborSolicitation& packet, char* data, size_t maxSize) const
        {
            if ((packet.target.family () != AF_INET6) || packet.target.isWildcard () || packet.target.isMulticast ())
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            char* cur = data;
            const char* end = data + maxSize;
            bool ok = true;
 
            struct nd_neighbor_solicit ns = {};
            ns.nd_ns_type = NeighborSolicit;
            ::memcpy (&ns.nd_ns_target, packet.target.addr (), sizeof (ns.nd_ns_target));
            ok &= writeBytes (cur, end, &ns, sizeof (ns));
            ok &= writeLinkAddress (cur, end, packet.link);
 
            return ok ? cur - data : -1;
        }
 
        ssize_t serialize (const NeighborAdvertisement& packet, char* data, size_t maxSize) const
        {
            return serialize (packet, data, maxSize, packet.link);
        }
 
        ssize_t serialize (const NeighborAdvertisement& packet, char* data, size_t maxSize,
                           const MacAddress& link) const
        {
            if ((packet.target.family () != AF_INET6) || packet.target.isWildcard () || packet.target.isMulticast ())
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            char* cur = data;
            const char* end = data + maxSize;
            bool ok = true;
 
            struct nd_neighbor_advert na = {};
            na.nd_na_type = NeighborAdvert;
            na.nd_na_flags_reserved = packet.flags;
            ::memcpy (&na.nd_na_target, packet.target.addr (), sizeof (na.nd_na_target));
            ok &= writeBytes (cur, end, &na, sizeof (na));
            ok &= writeLinkAddress (cur, end, link, TargetLinkAddress);
 
            return ok ? cur - data : -1;
        }
 
        int deserialize (RouterSolicitation& packet, const char* data, size_t size) const
        {
            const char* cur = data;
            const char* end = data + size;
 
            struct nd_router_solicit rs = {};
            if (!readBytes (cur, end, &rs, sizeof (rs)))
            {
                return -1;
            }
 
            if ((rs.nd_rs_type != RouterSolicit) || (rs.nd_rs_code != 0))
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return -1;
            }
 
            packet.link = MacAddress ();
 
            return readOptions (cur, end, [&packet] (const uint8_t* option, size_t size) {
                if ((option[0] == SourceLinkAddress) && (size >= _optionHeaderSize + ETH_ALEN))
                {
                    packet.link = MacAddress (option + _optionHeaderSize, ETH_ALEN);
                }
            });
        }
 
        int deserialize (RouterAdvertisement& packet, const char* data, size_t size) const
        {
            const char* cur = data;
            const char* end = data + size;
 
            struct nd_router_advert ra = {};
            if (!readBytes (cur, end, &ra, sizeof (ra)))
            {
                return -1;
            }
 
            if ((ra.nd_ra_type != RouterAdvert) || (ra.nd_ra_code != 0))
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return -1;
            }
 
            packet.hopLimit = ra.nd_ra_curhoplimit;
            packet.flags = ra.nd_ra_flags_reserved;
            packet.lifetime = ntohs (ra.nd_ra_router_lifetime);
            packet.reachable = ntohl (ra.nd_ra_reachable);
            packet.retransmit = ntohl (ra.nd_ra_retransmit);
            packet.link = MacAddress ();
            packet.mtu = 0;
            packet.prefixes.clear ();
            packet.rdnss.clear ();
 
            return readOptions (cur, end, [&packet] (const uint8_t* option, size_t size) {
                switch (option[0])
                {
                    case SourceLinkAddress:
                        if (size >= _optionHeaderSize + ETH_ALEN)
                        {
                            packet.link = MacAddress (option + _optionHeaderSize, ETH_ALEN);
                        }
                        break;
 
                    case Mtu:
                        if (size == sizeof (struct nd_opt_mtu))
                        {
                            struct nd_opt_mtu mtu;
                            ::memcpy (&mtu, option, sizeof (mtu));
                            packet.mtu = ntohl (mtu.nd_opt_mtu_mtu);
                        }
                        break;
 
                    case PrefixInformation:
                        if (size == sizeof (struct nd_opt_prefix_info))
                        {
                            struct nd_opt_prefix_info pi;
                            ::memcpy (&pi, option, sizeof (pi));
 
                            if (pi.nd_opt_pi_prefix_len <= 128)
                            {
                                NdpPrefix prefix;
                                prefix.prefix = IpAddress (&pi.nd_opt_pi_prefix, sizeof (pi.nd_opt_pi_prefix));
                                prefix.length = pi.nd_opt_pi_prefix_len;
                                prefix.flags = pi.nd_opt_pi_flags_reserved;
                                prefix.valid = ntohl (pi.nd_opt_pi_valid_time);
                                prefix.preferred = ntohl (pi.nd_opt_pi_preferred_time);
                                packet.prefixes.push_back (std::move (prefix));
                            }
                        }
                        break;
 
                    case RecursiveDnsServer:
                        if ((size > sizeof (RdnssHeader)) &&
                            (((size - sizeof (RdnssHeader)) % sizeof (struct in6_addr)) == 0))
                        {
                            RdnssHeader header;
                            ::memcpy (&header, option, sizeof (header));
 
                            NdpRdnss rdnss;
                            rdnss.lifetime = ntohl (header.lifetime);
                            rdnss.servers.reserve ((size - sizeof (RdnssHeader)) / sizeof (struct in6_addr));
 
                            for (size_t offset = sizeof (RdnssHeader); offset < size;
                                 offset += sizeof (struct in6_addr))
                            {
                                rdnss.servers.emplace_back (option + offset, sizeof (struct in6_addr));
                            }
 
                            packet.rdnss.push_back (std::move (rdnss));
                        }
                        break;
 
                    default:
                        break;
                }
            });
        }
 
        int deserialize (NeighborSolicitation& packet, const char* data, size_t size) const
        {
            const char* cur = data;
            const char* end = data + size;
 
            struct nd_neighbor_solicit ns = {};
            if (!readBytes (cur, end, &ns, sizeof (ns)))
            {
                return -1;
            }
 
            if ((ns.nd_ns_type != NeighborSolicit) || (ns.nd_ns_code != 0))
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return -1;
            }
 
            packet.target = IpAddress (&ns.nd_ns_target, sizeof (ns.nd_ns_target));
            if (packet.target.isWildcard () || packet.target.isMulticast ())
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            packet.link = MacAddress ();
 
            return readOptions (cur, end, [&packet] (const uint8_t* option, size_t size) {
                if ((option[0] == SourceLinkAddress) && (size >= _optionHeaderSize + ETH_ALEN))
                {
                    packet.link = MacAddress (option + _optionHeaderSize, ETH_ALEN);
                }
            });
        }
 
        int deserialize (NeighborAdvertisement& packet, const char* data, size_t size) const
        {
            const char* cur = data;
            const char* end = data + size;
 
            struct nd_neighbor_advert na = {};
            if (!readBytes (cur, end, &na, sizeof (na)))
            {
                return -1;
            }
 
            if ((na.nd_na_type != NeighborAdvert) || (na.nd_na_code != 0))
            {
                lastError = make_error_code (Errc::MessageUnknown);
                return -1;
            }
 
            packet.target = IpAddress (&na.nd_na_target, sizeof (na.nd_na_target));
            if (packet.target.isWildcard () || packet.target.isMulticast ())
            {
                lastError = make_error_code (Errc::InvalidParam);
                return -1;
            }
 
            packet.flags = na.nd_na_flags_reserved;
            packet.link = MacAddress ();
 
            return readOptions (cur, end, [&packet] (const uint8_t* option, size_t size) {
                if ((option[0] == TargetLinkAddress) && (size >= _optionHeaderSize + ETH_ALEN))
                {
                    packet.link = MacAddress (option + _optionHeaderSize, ETH_ALEN);
                }
            });
        }
 
    protected:
        struct __attribute__ ((packed)) RdnssHeader
        {
            uint8_t type;
 
            uint8_t len;
 
            uint16_t reserved;
 
            uint32_t lifetime;
        };
 
        static bool writeLinkAddress (char*& cur, const char* end, const MacAddress& link,
                                      OptionType type = SourceLinkAddress)
        {
            if (link.isWildcard ())
            {
                return true;
            }
 
            uint8_t option[_optionHeaderSize + ETH_ALEN] = {type, 1};
            ::memcpy (option + _optionHeaderSize, link.addr (), ETH_ALEN);
 
            return writeBytes (cur, end, option, sizeof (option));
        }
 
        template <typename Handler>
        static int readOptions (const char* cur, const char* end, Handler&& handler)
        {
            uint8_t option[_maxOptionSize];
 
            for (;;)
            {
                if (cur == end)
                {
                    return 0;
                }
 
                if (!readBytes (cur, end, option, _optionHeaderSize) || (option[1] == 0))
                {
                    lastError = make_error_code (Errc::InvalidParam);
                    return -1;
                }
 
                const size_t size = static_cast<size_t> (option[1]) << 3;
                if (!readBytes (cur, end, option + _optionHeaderSize, size - _optionHeaderSize))
                {
                    return -1;
                }
 
                handler (option, size);
            }
        }
 
        static constexpr size_t _optionHeaderSize = 2;
 
        static constexpr size_t _maxOptionSize = 255 << 3;
 
        static constexpr size_t _maxDnsServers = 127;
 
    public:
        static constexpr size_t maxRouterSolicitationSize =
            sizeof (struct nd_router_solicit) + _optionHeaderSize + ETH_ALEN;
 
        static constexpr size_t maxNeighborSolicitationSize =
            sizeof (struct nd_neighbor_solicit) + _optionHeaderSize + ETH_ALEN;
 
        static constexpr size_t maxNeighborAdvertisementSize =
            sizeof (struct nd_neighbor_advert) + _optionHeaderSize + ETH_ALEN;
    };
}
 
#endif