net.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <array>
#include <concepts>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace idfxx::net {
 
class ipv4_addr {
public:
    [[nodiscard]] static std::optional<ipv4_addr> parse(std::string_view s) noexcept;
 
    constexpr ipv4_addr() noexcept = default;
 
    [[nodiscard]] static constexpr ipv4_addr any() noexcept { return ipv4_addr{}; }
 
    constexpr explicit ipv4_addr(uint32_t addr) noexcept
        : _addr(addr) {}
 
    constexpr ipv4_addr(uint8_t a, uint8_t b, uint8_t c, uint8_t d) noexcept
        : _addr(
              static_cast<uint32_t>(a) | (static_cast<uint32_t>(b) << 8) | (static_cast<uint32_t>(c) << 16) |
              (static_cast<uint32_t>(d) << 24)
          ) {}
 
    [[nodiscard]] constexpr uint32_t addr() const noexcept { return _addr; }
 
    [[nodiscard]] constexpr bool is_any() const noexcept { return _addr == 0; }
 
    [[nodiscard]] constexpr bool operator==(const ipv4_addr&) const noexcept = default;
 
private:
    uint32_t _addr = 0;
};
 
class ipv6_addr {
public:
    [[nodiscard]] static std::optional<ipv6_addr> parse(std::string_view s) noexcept;
 
    constexpr ipv6_addr() noexcept = default;
 
    [[nodiscard]] static constexpr ipv6_addr any() noexcept { return ipv6_addr{}; }
 
    constexpr explicit ipv6_addr(std::array<uint32_t, 4> words, uint8_t zone = 0) noexcept
        : _addr(words)
        , _zone(zone) {}
 
    [[nodiscard]] constexpr const std::array<uint32_t, 4>& addr() const noexcept { return _addr; }
 
    [[nodiscard]] constexpr uint8_t zone() const noexcept { return _zone; }
 
    [[nodiscard]] constexpr bool is_any() const noexcept {
        return _addr[0] == 0 && _addr[1] == 0 && _addr[2] == 0 && _addr[3] == 0;
    }
 
    [[nodiscard]] constexpr bool operator==(const ipv6_addr&) const noexcept = default;
 
private:
    std::array<uint32_t, 4> _addr = {};
    uint8_t _zone = 0;
};
 
template<typename T>
concept ip_address = std::same_as<T, ipv4_addr> || std::same_as<T, ipv6_addr>;
 
struct ipv4_info {
    ipv4_addr ip;      
    ipv4_addr netmask; 
    ipv4_addr gateway; 
    [[nodiscard]] constexpr bool operator==(const ipv4_info&) const noexcept = default;
};
 
struct ipv6_info {
    ipv6_addr ip; 
};
 
// ----- backward-compatibility aliases -----
//
// `ipv4_addr` / `ipv6_addr` / `ipv4_info` / `ipv6_info` were originally named
// `ip4_addr` / `ip6_addr` / `ip4_info` / `ip6_info`. The aliases preserve the
// old spelling for code written against earlier releases.
using ip4_addr [[deprecated("use ipv4_addr")]] = ipv4_addr;
using ip6_addr [[deprecated("use ipv6_addr")]] = ipv6_addr;
using ip4_info [[deprecated("use ipv4_info")]] = ipv4_info;
using ip6_info [[deprecated("use ipv6_info")]] = ipv6_info;
 
} // namespace idfxx::net
 
// =============================================================================
// String conversions (in idfxx namespace)
// =============================================================================
 
namespace idfxx {
 
[[nodiscard]] std::string to_string(net::ipv4_addr addr);
 
[[nodiscard]] std::string to_string(net::ipv6_addr addr);
 
[[nodiscard]] std::string to_string(net::ipv4_info info);
 
} // namespace idfxx
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <algorithm>
#include <format>
namespace std {
 
template<>
struct formatter<idfxx::net::ipv4_addr> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::net::ipv4_addr addr, FormatContext& ctx) const {
        auto s = idfxx::to_string(addr);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
 
template<>
struct formatter<idfxx::net::ipv6_addr> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::net::ipv6_addr addr, FormatContext& ctx) const {
        auto s = idfxx::to_string(addr);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
 
template<>
struct formatter<idfxx::net::ipv4_info> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::net::ipv4_info info, FormatContext& ctx) const {
        auto s = idfxx::to_string(info);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
 
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT