ip.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_IP_HPP
#define MTCORE_IP_HPP
 
#include "mtcore/colls/result.hpp"
#include "mtcore/colls/slice.hpp"
#include "mtcore/core.hpp"
#include "mtcore/io/writer.hpp"


namespace mtcore {

  enum class IpInitError { INVALID_INPUT };

  enum class Ip6ConversionError { NOT_IP4 };

  struct IPv6;

  struct IPv4 {
    u32 bits = 0;
 
    [[nodiscard]] Result<void, IpInitError> init(const Slice<const char> &str);
    [[nodiscard]] Result<void, IpInitError> init(const Slice<char> &str);
    [[nodiscard]] Result<void, IpInitError> init(const std::string_view &str);
    [[nodiscard]] Result<void, IpInitError> init(const std::string &str);
 
    [[nodiscard]] IPv6 to_v6() const noexcept;
 
    [[nodiscard]] std::strong_ordering operator<=>(const IPv4 &o) const noexcept { return bits <=> o.bits; }
    [[nodiscard]] bool operator==(const IPv4 &o) const noexcept { return (*this <=> o) == 0; }
    [[nodiscard]] bool operator!=(const IPv4 &o) const noexcept { return (*this <=> o) != 0; }
    [[nodiscard]] bool operator<=(const IPv4 &o) const noexcept { return (*this <=> o) <= 0; }
    [[nodiscard]] bool operator>=(const IPv4 &o) const noexcept { return (*this <=> o) >= 0; }
    [[nodiscard]] bool operator<(const IPv4 &o) const noexcept { return (*this <=> o) < 0; }
    [[nodiscard]] bool operator>(const IPv4 &o) const noexcept { return (*this <=> o) > 0; }
  };

  struct IPv6 {
    u64 high = 0;
    u64 low  = 0;
 
    [[nodiscard]] Result<void, IpInitError> init(const Slice<const char> &str);
    [[nodiscard]] Result<void, IpInitError> init(const Slice<char> &str);
    [[nodiscard]] Result<void, IpInitError> init(const std::string_view &str);
    [[nodiscard]] Result<void, IpInitError> init(const std::string &str);
 
    [[nodiscard]] std::strong_ordering operator<=>(const IPv6 &o) const noexcept {
      const auto highCmp = high <=> o.high;
      const auto lowCmp  = low <=> o.low;
      if (highCmp == std::strong_ordering::equal) {
        return lowCmp;
      }
      return highCmp;
    }
    [[nodiscard]] bool operator==(const IPv6 &o) const noexcept { return (*this <=> o) == 0; }
    [[nodiscard]] bool operator!=(const IPv6 &o) const noexcept { return (*this <=> o) != 0; }
    [[nodiscard]] bool operator<=(const IPv6 &o) const noexcept { return (*this <=> o) <= 0; }
    [[nodiscard]] bool operator>=(const IPv6 &o) const noexcept { return (*this <=> o) >= 0; }
    [[nodiscard]] bool operator<(const IPv6 &o) const noexcept { return (*this <=> o) < 0; }
    [[nodiscard]] bool operator>(const IPv6 &o) const noexcept { return (*this <=> o) > 0; }
 
    [[nodiscard]] bool is_ip4() const noexcept {
      return high == 0 && ((low & 0xffffffff00000000ull) == 0x0000ffff00000000ull);
    }
 
    [[nodiscard]] Result<IPv4, Ip6ConversionError> to_ip4() const;
  };
 
  struct SubnetMaskV6;
  struct SubnetV4;

  enum class SubnetMaskError {
    INVALID_SUBNET_ID,
  };

  struct SubnetMaskV4 {
    u32 mask = 0;
    u8 id    = 0;

    inline static SubnetMaskV4 by_id(u8 id);

    constexpr static bool valid_id(u8 id);

    SubnetV4 subnet_ip(const IPv4 &ip);
  };
 
  namespace impl {
    constexpr std::array<SubnetMaskV4, 33> init_ip4_masks() {
      std::array<SubnetMaskV4, 33> res = {};
      for (size_t i = 1; i < res.size(); ++i) {
        res[i].id   = i;
        res[i].mask = (res[i - 1].mask >> 1) | 0b10000000000000000000000000000000;
      }
      return res;
    }
 
    constexpr auto ip4SubnetMasks = init_ip4_masks();
  }  // namespace impl
 
  constexpr bool SubnetMaskV4::valid_id(const u8 id) { return id < impl::ip4SubnetMasks.size(); }
 
  inline SubnetMaskV4 SubnetMaskV4::by_id(const u8 id) {
    ensure(valid_id(id));
    return impl::ip4SubnetMasks[id];
  }
 
  struct SubnetV6;

  struct SubnetMaskV6 {
    u8 id        = 0;
    u64 maskHigh = 0;
    u64 maskLow  = 0;

    inline static SubnetMaskV6 by_id(u8 id);

    constexpr static bool valid_id(u8 id);

    SubnetV6 subnet_ip(const IPv6 &ip);
  };
 
  namespace impl {
    constexpr std::array<SubnetMaskV6, 129> init_ip6_masks() {
      std::array<SubnetMaskV6, 129> res = {};
      for (size_t i = 1; i < res.size(); ++i) {
        res[i].id = i;
        if (res[i - 1].maskHigh != std::numeric_limits<u64>::max()) {
          res[i].maskHigh =
            (res[i - 1].maskHigh >> 1) | 0b1000000000000000000000000000000000000000000000000000000000000000;
        }
        else {
          res[i].maskHigh = std::numeric_limits<u64>::max();
          res[i].maskLow =
            (res[i - 1].maskLow >> 1) | 0b1000000000000000000000000000000000000000000000000000000000000000;
        }
      }
      return res;
    }
 
    constexpr auto ip6SubnetMasks = init_ip6_masks();
  }  // namespace impl
 
  inline SubnetMaskV6 SubnetMaskV6::by_id(u8 id) {
    ensure(valid_id(id));
    return impl::ip6SubnetMasks[id];
  }
 
  constexpr bool SubnetMaskV6::valid_id(u8 id) { return id < impl::ip6SubnetMasks.size(); }

  struct SubnetV4 {
    IPv4 ip    = {};
    u8 mask_id = 0;

    [[nodiscard]] bool is_valid() const {
      if (!SubnetMaskV4::valid_id(mask_id)) {
        return false;
      }
      return SubnetMaskV4::by_id(mask_id).subnet_ip(ip).ip == ip;
    }
 
    bool operator==(const SubnetV4 &o) const { return mask_id == o.mask_id && ip == o.ip; }
    bool operator!=(const SubnetV4 &o) const { return !(o == *this); }
  };

  struct SubnetV6 {
    IPv6 ip    = {};
    u8 mask_id = 0;

    [[nodiscard]] bool is_valid() const {
      if (!SubnetMaskV6::valid_id(mask_id)) {
        return false;
      }
      return SubnetMaskV6::by_id(mask_id).subnet_ip(ip).ip == ip;
    }
 
    bool operator==(const SubnetV6 &o) const { return mask_id == o.mask_id && ip == o.ip; }
    bool operator!=(const SubnetV6 &o) const { return !(o == *this); }
  };
}  // namespace mtcore
 
#include "io/formats.hpp"
 
namespace mtcore {
  template<>
  struct io::Formatter<IPv4> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, FormatOptions, const IPv4 &val) {
      const auto p1 = (val.bits >> 24) & 0xff;
      const auto p2 = (val.bits >> 16) & 0xff;
      const auto p3 = (val.bits >> 8) & 0xff;
      const auto p4 = (val.bits >> 0) & 0xff;
      return print(writer, "{d}.{d}.{d}.{d}", p1, p2, p3, p4);
    }
  };

  template<>
  struct io::Formatter<IPv6> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, FormatOptions opts, const IPv6 &val) {
      auto chunks = std::array{
        (val.high >> 48) & 0xffff, (val.high >> 32) & 0xffff, (val.high >> 16) & 0xffff, (val.high >> 0) & 0xffff,
        (val.low >> 48) & 0xffff,  (val.low >> 32) & 0xffff,  (val.low >> 16) & 0xffff,  (val.low >> 0) & 0xffff,
      };
      auto data = slice_from(chunks);
 
      auto fmtStr = "{\\::0<4;x}";
 
      if (slices::contains('z', opts.formatStr)) {
        fmtStr = "{\\::x}";
      }
 
      if (slices::contains('4', opts.formatStr) && val.is_ip4()) {
        auto prefix = slice_from("0000:0000:0000:0000:0000:ffff:");
        if (slices::contains('t', opts.formatStr)) {
          prefix = slice_from("::ffff:");
        }
        else if (slices::contains('z', opts.formatStr)) {
          prefix = slice_from("0:0:0:0:0:ffff:");
        }
        size_t written = 0;
        auto preRes    = writer.write_all(prefix);
        if (preRes.is_error()) {
          return preRes.error();
        }
        written += prefix.size();
        auto ip4    = val.to_ip4().value();
        auto ip4Res = format(writer, {}, ip4);
        if (ip4Res.is_error()) {
          return ip4Res.error();
        }
        written += ip4Res.value();
        return written;
      }
 
      // If there are zeros to truncate
      if (slices::contains('t', opts.formatStr) && slices::contains(0, data)) {
        size_t i = 0;
        for (; i < data.size() && data[i] != 0; ++i) {}
 
        auto skipStart = slices::first_index(0, data);
        ensure(skipStart.has_value());
        auto skipEndOpt = slices::first_index_not(0, data.sub(skipStart.value()));
        auto skipEnd    = skipEndOpt.has_value() ? skipEndOpt.value() + skipStart.value() : data.size();
 
        auto printPart1 = data.sub(0, skipStart.value());
        auto printPart2 = data.sub(skipEnd);
 
        size_t written = 0;
 
        if (!printPart1.empty()) {
          auto p1Res = print(writer, fmtStr, printPart1);
          if (p1Res.is_error()) {
            return p1Res.error();
          }
          written += p1Res.value();
        }
 
        auto sepRes = writer.write_all(slice_from("::"));
        if (sepRes.is_error()) {
          return sepRes.error();
        }
        written += 2;
 
        if (!printPart2.empty()) {
          auto p2Res = print(writer, fmtStr, printPart2);
          if (p2Res.is_error()) {
            return p2Res.error();
          }
          written += p2Res.value();
        }
 
        return written;
      }
 
      return print(writer, fmtStr, data);
    }
  };

  template<>
  struct io::Formatter<SubnetMaskV4> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, FormatOptions,
                                                            const SubnetMaskV4 &val) {
      return print(writer, "/{d}", val.id);
    }
  };

  template<>
  struct io::Formatter<SubnetMaskV6> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> &writer, FormatOptions,
                                                            const SubnetMaskV6 &val) {
      return print(writer, "/{d}", val.id);
    }
  };

  template<>
  struct io::Formatter<SubnetV4> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> *writer, FormatOptions, const SubnetV4 &val) {
      if (!val.is_valid()) {
        return print(writer, "[INVALID SUBNET V4]{}{}", val.ip, SubnetMaskV4::by_id(val.mask_id));
      }
      return print(writer, "{}{}", val.ip, SubnetMaskV4::by_id(val.mask_id));
    }
  };

  template<>
  struct io::Formatter<SubnetV6> {
    template<WriterImpl WI>
    static Result<size_t, typename Writer<WI>::ErrType> fmt(Writer<WI> *writer, FormatOptions, const SubnetV6 &val) {
      if (!val.is_valid()) {
        return print(writer, "[INVALID SUBNET V6]{}{}", val.ip, SubnetMaskV6::by_id(val.mask_id));
      }
      return print(writer, "{zt4}{}", val.ip, SubnetMaskV4::by_id(val.mask_id));
    }
  };
}  // namespace mtcore
 
#endif  // MTCORE_IP_HPP