ip_address.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_IP_ADDRESS_HPP
#define JOIN_CORE_IP_ADDRESS_HPP
 
// C++.
#include <ostream>
#include <compare>
#include <string>
#include <memory>
#include <vector>
 
// C.
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
 
namespace join
{
    class IpAddress;
    class IpAddressImpl;
 
    using IpAddressList = std::vector<IpAddress>;
 
    class IpAddress
    {
    public:
        IpAddress ();
 
        IpAddress (int family);
 
        IpAddress (const IpAddress& address);
 
        IpAddress (IpAddress&& address);
 
        IpAddress (const struct sockaddr& address);
 
        IpAddress (const void* address, socklen_t length);
 
        IpAddress (const void* address, socklen_t length, uint32_t scope);
 
        IpAddress (const std::string& address, int family);
 
        IpAddress (const std::string& address);
 
        IpAddress (const char* address, int family);
 
        IpAddress (const char* address);
 
        IpAddress (int prefix, int family);
 
        IpAddress& operator= (const IpAddress& address);
 
        IpAddress& operator= (IpAddress&& address);
 
        IpAddress& operator= (const struct sockaddr& address);
 
        ~IpAddress ();
 
        int family () const;
 
        const void* addr () const;
 
        socklen_t length () const;
 
        uint32_t scope () const;
 
        int prefix () const;
 
        bool isWildcard () const;
 
        bool isLoopBack () const;
 
        bool isLinkLocal () const;
 
        bool isSiteLocal () const;
 
        bool isUniqueLocal () const;
 
        bool isUnicast () const;
 
        bool isBroadcast (int prefix = 0) const;
 
        bool isMulticast () const;
 
        bool isGlobal () const;
 
        static bool isIpAddress (const std::string& address);
 
        bool isIpv6Address () const;
 
        static bool isIpv6Address (const std::string& address);
 
        bool isIpv4Compat () const;
 
        bool isIpv4Mapped () const;
 
        bool isIpv4Address () const;
 
        static bool isIpv4Address (const std::string& address);
 
        IpAddress toIpv6 () const;
 
        IpAddress toIpv4 () const;
 
        std::string toString () const;
 
        std::string toArpa () const;
 
        void clear ();
 
        static IpAddress ipv4Address (const std::string& interface);
 
        IpAddress operator~() const;
 
        uint8_t& operator[] (size_t position);
 
        const uint8_t& operator[] (size_t position) const;
 
        static const IpAddress ipv6Wildcard;
 
        static const IpAddress ipv6AllNodes;
 
        static const IpAddress ipv6SolicitedNodes;
 
        static const IpAddress ipv6Routers;
 
        static constexpr socklen_t ipv6Length = 16;
 
        static const IpAddress ipv4Wildcard;
 
        static const IpAddress ipv4Broadcast;
 
        static constexpr socklen_t ipv4Length = 4;
 
    private:
        std::unique_ptr<IpAddressImpl> _ip;
    };
 
    bool operator== (const IpAddress& a, const IpAddress& b);
 
    std::strong_ordering operator<=> (const IpAddress& a, const IpAddress& b);
 
    IpAddress operator& (const IpAddress& a, const IpAddress& b);
 
    IpAddress operator| (const IpAddress& a, const IpAddress& b);
 
    IpAddress operator^ (const IpAddress& a, const IpAddress& b);
 
    std::ostream& operator<< (std::ostream& out, const IpAddress& address);
}
 
namespace std
{
    template <>
    struct hash<join::IpAddress>
    {
        size_t operator() (const join::IpAddress& ipAddress) const noexcept
        {
            size_t h = 0;
            const uint8_t* bytes = reinterpret_cast<const uint8_t*> (ipAddress.addr ());
            for (socklen_t i = 0; i < ipAddress.length (); ++i)
            {
                h ^= std::hash<uint8_t>{}(bytes[i] + 0x9e3779b9 + (h << 6) + (h >> 2));
            }
            return h;
        }
    };
}
 
#endif