dhcp_option.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_DHCP_OPTION_HPP
#define JOIN_FABRIC_DHCP_OPTION_HPP
 
// libjoin.
#include <join/mac_address.hpp>
#include <join/ip_address.hpp>
#include <join/variant.hpp>
#include <join/error.hpp>
 
// C++.
#include <type_traits>
#include <limits>
#include <sstream>
#include <string>
#include <vector>
#include <map>
 
namespace join
{
    using ByteList = std::vector<uint8_t>;
 
    using WordList = std::vector<uint16_t>;
 
    using IpList = std::vector<IpAddress>;
 
    using DhcpOptionValue =
        Variant<uint8_t, uint16_t, uint32_t, int32_t, std::string, IpAddress, MacAddress, ByteList, WordList, IpList>;
 
    class DhcpOption
    {
    public:
        enum Code : uint8_t
        {
            Pad = 0,
            SubnetMask = 1,
            TimeOffset = 2,
            Router = 3,
            TimeServer = 4,
            NameServer = 5,
            DomainNameServer = 6,
            LogServer = 7,
            CookieServer = 8,
            LprServer = 9,
            ImpressServer = 10,
            ResourceLocationServer = 11,
            HostName = 12,
            BootFileSize = 13,
            MeritDumpFile = 14,
            DomainName = 15,
            SwapServer = 16,
            RootPath = 17,
            ExtensionsPath = 18,
            IpForwarding = 19,
            NonLocalSourceRouting = 20,
            PolicyFilter = 21,
            MaximumDatagramReassemblySize = 22,
            DefaultIpTimeToLive = 23,
            PathMtuAgingTimeout = 24,
            PathMtuPlateauTable = 25,
            InterfaceMtu = 26,
            AllSubnetsAreLocal = 27,
            BroadcastAddress = 28,
            PerformMaskDiscovery = 29,
            MaskSupplier = 30,
            PerformRouterDiscovery = 31,
            RouterSolicitationAddress = 32,
            StaticRoute = 33,
            TrailerEncapsulation = 34,
            ArpCacheTimeout = 35,
            EthernetEncapsulation = 36,
            TcpDefaultTtl = 37,
            TcpKeepaliveInterval = 38,
            TcpKeepaliveGarbage = 39,
            NisDomain = 40,
            NetworkInformationServer = 41,
            NtpServer = 42,
            VendorSpecificInformation = 43,
            NetbiosNameServer = 44,
            NetbiosDatagramDistributionServer = 45,
            NetbiosNodeType = 46,
            NetbiosScope = 47,
            XWindowFontServer = 48,
            XWindowDisplayManager = 49,
            RequestedIpAddress = 50,
            IpAddressLeaseTime = 51,
            OptionOverload = 52,
            DhcpMessageType = 53,
            ServerIdentifier = 54,
            ParameterRequestList = 55,
            Message = 56,
            MaximumDhcpMessageSize = 57,
            RenewalTimeValue = 58,
            RebindingTimeValue = 59,
            VendorClassIdentifier = 60,
            ClientIdentifier = 61,
            TftpServerName = 66,
            BootFileName = 67,
            MobileIpHomeAgent = 68,
            SmtpServer = 69,
            Pop3Server = 70,
            NntpServer = 71,
            DefaultWwwServer = 72,
            DefaultFingerServer = 73,
            DefaultIrcServer = 74,
            StreetTalkServer = 75,
            StreetTalkDirectoryAssistanceServer = 76,
            End = 255,
        };
 
        enum Type
        {
            Byte,  
            Word,  
            Long,  
            SLong, 
            Text,  
            Ip,    
            Mac,   
            Bytes, 
            Words, 
            Ips,   
        };
 
        struct Info
        {
            uint8_t code;     
            const char* name; 
            Type type;        
            uint32_t min;     
            uint32_t max;     
            uint32_t mask;    
        };
 
        using Options = std::map<uint8_t, DhcpOptionValue>;
 
        using const_iterator = Options::const_iterator;
 
        DhcpOption () = default;
 
        DhcpOption (const_iterator first, const_iterator last)
        : _options (first, last)
        {
        }
 
        DhcpOption (const DhcpOption& other) = default;
 
        DhcpOption& operator= (const DhcpOption& other) = default;
 
        DhcpOption (DhcpOption&& other) = default;
 
        DhcpOption& operator= (DhcpOption&& other) = default;
 
        ~DhcpOption () = default;
 
        const DhcpOptionValue& at (uint8_t code) const
        {
            return _options.at (code);
        }
 
        template <typename T>
        const T* getIf (uint8_t code) const
        {
            auto it = _options.find (code);
            return (it == _options.end ()) ? nullptr : it->second.getIf<T> ();
        }
 
        const_iterator find (uint8_t code) const
        {
            return _options.find (code);
        }
 
        bool contains (uint8_t code) const
        {
            return (find (code) != end ());
        }
 
        const_iterator begin () const
        {
            return _options.begin ();
        }
 
        const_iterator cbegin () const
        {
            return _options.cbegin ();
        }
 
        const_iterator end () const
        {
            return _options.end ();
        }
 
        const_iterator cend () const
        {
            return _options.cend ();
        }
 
        bool empty () const
        {
            return _options.empty ();
        }
 
        size_t size () const
        {
            return _options.size ();
        }
 
        size_t erase (uint8_t code)
        {
            return _options.erase (code);
        }
 
        void clear ()
        {
            _options.clear ();
        }
 
        template <typename T>
        bool insert (uint8_t code, T&& value)
        {
            DhcpOptionValue converted;
 
            if (!convert (code, std::forward<T> (value), converted))
            {
                return false;
            }
 
            if (!_options.emplace (code, std::move (converted)).second)
            {
                lastError = make_error_code (Errc::InUse);
                return false;
            }
 
            return true;
        }
 
        void insert (const_iterator first, const_iterator last)
        {
            _options.insert (first, last);
        }
 
        void swap (DhcpOption& other)
        {
            _options.swap (other._options);
        }
 
        std::string dump () const
        {
            std::stringstream stream;
 
            for (auto const& option : _options)
            {
                stream << codeName (option.first) << " (" << int (option.first) << "): ";
                write (stream, option.first, option.second);
                stream << "\n";
            }
 
            return stream.str ();
        }
 
        template <typename T>
        static bool isValid (uint8_t code, T&& value)
        {
            DhcpOptionValue converted;
            return convert (code, std::forward<T> (value), converted);
        }
 
        static const Info* describe (uint8_t code) noexcept;
 
    protected:
        static const char* codeName (uint8_t code) noexcept;
 
        static void write (std::ostream& stream, uint8_t code, const DhcpOptionValue& value);
 
        static bool accepts (const Info& info, uint32_t value) noexcept
        {
            if (info.mask)
            {
                return (value < 32) && ((info.mask >> value) & 1u);
            }
 
            if (info.max)
            {
                return (value >= info.min) && (value <= info.max);
            }
 
            return true;
        }
 
        template <typename Target, typename Source>
        static typename std::enable_if<std::is_signed<Source>::value, bool>::type fits (Source value) noexcept
        {
            if (value < 0)
            {
                return std::is_signed<Target>::value &&
                       static_cast<int64_t> (value) >= static_cast<int64_t> (std::numeric_limits<Target>::min ());
            }
 
            return static_cast<uint64_t> (value) <= static_cast<uint64_t> (std::numeric_limits<Target>::max ());
        }
 
        template <typename Target, typename Source>
        static typename std::enable_if<!std::is_signed<Source>::value, bool>::type fits (Source value) noexcept
        {
            return static_cast<uint64_t> (value) <= static_cast<uint64_t> (std::numeric_limits<Target>::max ());
        }
 
        template <typename Target, typename Source>
        static bool store (const Info& info, Source value, DhcpOptionValue& out)
        {
            if (!fits<Target> (value) || !accepts (info, static_cast<uint32_t> (value)))
            {
                lastError = make_error_code (Errc::InvalidParam);
                return false;
            }
 
            out = static_cast<Target> (value);
 
            return true;
        }
 
        static bool invalid () noexcept
        {
            lastError = make_error_code (Errc::InvalidParam);
            return false;
        }
 
        template <typename T>
        static typename std::enable_if<std::is_integral<typename std::decay<T>::type>::value, bool>::type convert (
            uint8_t code, T value, DhcpOptionValue& out)
        {
            const Info* info = describe (code);
            if (info == nullptr)
            {
                return invalid ();
            }
 
            switch (info->type)
            {
                case Byte:
                    return store<uint8_t> (*info, value, out);
 
                case Word:
                    return store<uint16_t> (*info, value, out);
 
                case Long:
                    return store<uint32_t> (*info, value, out);
 
                case SLong:
                    return store<int32_t> (*info, value, out);
 
                default:
                    break;
            }
 
            return invalid ();
        }
 
        static bool convert (uint8_t code, const std::string& value, DhcpOptionValue& out);
 
        static bool convert (uint8_t code, const char* value, DhcpOptionValue& out)
        {
            return convert (code, std::string (value), out);
        }
 
        static bool convert (uint8_t code, const IpAddress& value, DhcpOptionValue& out)
        {
            const Info* info = describe (code);
            if ((info == nullptr) || (info->type != Ip) || (value.family () != AF_INET))
            {
                return invalid ();
            }
 
            out = value;
 
            return true;
        }
 
        static bool convert (uint8_t code, const MacAddress& value, DhcpOptionValue& out)
        {
            const Info* info = describe (code);
            if ((info == nullptr) || (info->type != Mac))
            {
                return invalid ();
            }
 
            out = value;
 
            return true;
        }
 
        static bool convert (uint8_t code, const ByteList& value, DhcpOptionValue& out);
 
        static bool convert (uint8_t code, const WordList& value, DhcpOptionValue& out);
 
        static bool convert (uint8_t code, const IpList& value, DhcpOptionValue& out);
 
        Options _options;
 
        friend bool operator== (const DhcpOption& lhs, const DhcpOption& rhs);
 
        friend bool operator!= (const DhcpOption& lhs, const DhcpOption& rhs);
 
        friend bool operator< (const DhcpOption& lhs, const DhcpOption& rhs);
 
        friend bool operator> (const DhcpOption& lhs, const DhcpOption& rhs);
 
        friend bool operator<= (const DhcpOption& lhs, const DhcpOption& rhs);
 
        friend bool operator>= (const DhcpOption& lhs, const DhcpOption& rhs);
    };
 
    inline bool operator== (const DhcpOption& lhs, const DhcpOption& rhs)
    {
        return lhs._options == rhs._options;
    }
 
    inline bool operator!= (const DhcpOption& lhs, const DhcpOption& rhs)
    {
        return lhs._options != rhs._options;
    }
 
    inline bool operator< (const DhcpOption& lhs, const DhcpOption& rhs)
    {
        return lhs._options < rhs._options;
    }
 
    inline bool operator> (const DhcpOption& lhs, const DhcpOption& rhs)
    {
        return lhs._options > rhs._options;
    }
 
    inline bool operator<= (const DhcpOption& lhs, const DhcpOption& rhs)
    {
        return lhs._options <= rhs._options;
    }
 
    inline bool operator>= (const DhcpOption& lhs, const DhcpOption& rhs)
    {
        return lhs._options >= rhs._options;
    }
 
    inline std::ostream& operator<< (std::ostream& out, const DhcpOption& options)
    {
        out << options.dump ();
        return out;
    }
}
 
#endif