ipv4address.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/result.h>
#include <promeki/platform.h>
#include <promeki/list.h>
 
#if defined(PROMEKI_PLATFORM_WINDOWS)
#include <winsock2.h>
#include <ws2tcpip.h>
#elif !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
#include <netinet/in.h>
#endif
 
PROMEKI_NAMESPACE_BEGIN
 
class Ipv4Address;
class Ipv6Address;
class MacAddress;
class TextStream;
 
class Ipv4Address {
        public:
                using List = ::promeki::List<Ipv4Address>;
 
                static Result<Ipv4Address> fromString(const String &str);
 
                static Ipv4Address fromUint32(uint32_t networkOrder) { return Ipv4Address(networkOrder); }
 
                static Ipv4Address any() { return Ipv4Address(); }
 
                static Ipv4Address loopback() { return Ipv4Address(127, 0, 0, 1); }
 
                static Ipv4Address broadcast() { return Ipv4Address(255, 255, 255, 255); }
 
                Ipv4Address() : _addr(0) {}
 
                explicit Ipv4Address(uint32_t networkOrder) : _addr(networkOrder) {}
 
                Ipv4Address(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
                    : _addr(static_cast<uint32_t>(a) << 24 | static_cast<uint32_t>(b) << 16 |
                            static_cast<uint32_t>(c) << 8 | static_cast<uint32_t>(d)) {}
 
                bool isNull() const { return _addr == 0; }
 
                bool isLoopback() const { return octet(0) == 127; }
 
                bool isMulticast() const { return (octet(0) & 0xF0) == 0xE0; }
 
                bool isLinkLocal() const { return octet(0) == 169 && octet(1) == 254; }
 
                bool isPrivate() const {
                        uint8_t a = octet(0);
                        uint8_t b = octet(1);
                        if (a == 10) return true;
                        if (a == 172 && (b & 0xF0) == 16) return true;
                        if (a == 192 && b == 168) return true;
                        return false;
                }
 
                bool isBroadcast() const { return _addr == 0xFFFFFFFF; }
 
                bool isInSubnet(Ipv4Address network, Ipv4Address mask) const {
                        return (_addr & mask._addr) == (network._addr & mask._addr);
                }
 
                bool isInSubnet(Ipv4Address network, int prefixLen) const;
 
                uint32_t toUint32() const { return _addr; }
 
                uint8_t octet(int index) const {
                        if (index < 0 || index > 3) return 0;
                        return static_cast<uint8_t>((_addr >> (24 - index * 8)) & 0xFF);
                }
 
                String toString() const;
 
                Ipv6Address toIpv6Mapped() const;
 
                MacAddress multicastMac() const;
 
#if !defined(PROMEKI_PLATFORM_EMSCRIPTEN)
                static Result<Ipv4Address> fromSockAddr(const struct sockaddr_in *sa);
 
                Error toSockAddr(struct sockaddr_in *sa) const;
#endif
 
                bool operator==(const Ipv4Address &other) const { return _addr == other._addr; }
                bool operator!=(const Ipv4Address &other) const { return _addr != other._addr; }
                bool operator<(const Ipv4Address &other) const { return _addr < other._addr; }
 
        private:
                uint32_t _addr; 
};
 
TextStream &operator<<(TextStream &stream, const Ipv4Address &addr);
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::Ipv4Address);
 
#endif // PROMEKI_ENABLE_CORE