srv6_header.hxx

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <optional>
#include <span>
 
#include "utils.hxx"
 
namespace vbvx {

enum class SRv6TlvType : uint8_t { Pad1 = 0u, PadN = 4u, Hmac = 5u };

struct [[gnu::packed]] SRv6Header {
  uint8_t next_header;
  uint8_t hdr_ext_len;
  uint8_t routing_type;
  uint8_t segments_left;
  uint8_t last_entry;
  uint8_t flags;
  uint16_t tag_be;
 
  constexpr auto header_length_bytes() const noexcept -> uint16_t {
    return ((static_cast<uint16_t>(hdr_ext_len) + 1u) * 8u);
  }
 
  constexpr auto last_entry_index() const noexcept -> uint8_t {
    return last_entry;
  }
 
  constexpr auto segments_count() const noexcept -> uint8_t {
    return static_cast<uint8_t>(static_cast<uint8_t>(last_entry) + 1u);
  }
 
  constexpr auto tag() const noexcept -> uint16_t { return autoswap(tag_be); }
 
  constexpr auto routing_type_value() const noexcept -> uint8_t {
    return routing_type;
  }
 
  constexpr bool is_valid_routing_type() const noexcept {
    return routing_type == 4u;
  }
 
  constexpr auto segment_list_ptr() const noexcept -> const uint8_t* {
    return reinterpret_cast<const uint8_t*>(this) + 8u;
  }
 
  constexpr auto segment_at(uint8_t idx) const noexcept
      -> std::span<const uint8_t, 16> {
    return std::span<const uint8_t, 16>{
        segment_list_ptr() + (static_cast<uint16_t>(idx) * 16u), 16u};
  }
 
  constexpr auto segment_list_bytes_len() const noexcept -> uint16_t {
    return static_cast<uint16_t>(segments_count()) * 16u;
  }
 
  constexpr auto tlv_offset() const noexcept -> uint16_t {
    return 8u + segment_list_bytes_len();
  }

  constexpr auto max_last_entry() const noexcept -> uint8_t {
    return (hdr_ext_len < 2u) ? 0u
                              : static_cast<uint8_t>((hdr_ext_len / 2u) - 1u);
  }

  constexpr bool
  validate_srh_bounds(uint16_t packet_remaining_len) const noexcept {
    const uint16_t hdr_len = header_length_bytes();
    if (hdr_len < 8u || (hdr_len % 8u) != 0u) {
      return false;
    }
    if (packet_remaining_len < hdr_len) {
      return false;
    }
    if (hdr_ext_len < 2u) {
      return false;
    }
    if (last_entry > max_last_entry()) {
      return false;
    }
    if (segments_left > static_cast<uint8_t>(last_entry + 1u)) {
      return false;
    }
    if (tlv_offset() > hdr_len) {
      return false;
    }
    return true;
  }
 
  constexpr auto tlv_bytes_len() const noexcept -> uint16_t {
    auto total = header_length_bytes();
    if (total <= tlv_offset()) {
      return 0u;
    }
    return total - tlv_offset();
  }
 
  constexpr auto tlv_first_ptr() const noexcept -> const uint8_t* {
    return reinterpret_cast<const uint8_t*>(this) + tlv_offset();
  }

  constexpr auto safe_tlv_region(uint16_t packet_remaining_len) const noexcept
      -> std::optional<std::span<const uint8_t>> {
    if (!validate_srh_bounds(packet_remaining_len)) {
      return std::nullopt;
    }
    return std::span<const uint8_t>{tlv_first_ptr(), tlv_bytes_len()};
  }

  constexpr auto safe_segment_at(uint8_t idx,
                                 uint16_t packet_remaining_len) const noexcept
      -> std::optional<std::span<const uint8_t, 16>> {
    if (!validate_srh_bounds(packet_remaining_len)) {
      return std::nullopt;
    }
    if (idx >= segments_count()) {
      return std::nullopt;
    }
    return segment_at(idx);
  }
};

struct SRv6Tlv {
  uint8_t type;
  uint8_t length;
  const uint8_t* value;
  uint16_t total_len;
};

class SRv6TlvIterator {
public:
  constexpr SRv6TlvIterator(const uint8_t* ptr, uint16_t len) noexcept
      : ptr_{ptr}, len_{len}, pos_{0} {}
 
  constexpr bool next(SRv6Tlv& out) noexcept {
    if (pos_ >= len_) {
      return false;
    }
 
    const uint8_t t = ptr_[pos_];
    if (t == static_cast<uint8_t>(SRv6TlvType::Pad1)) {
      out = SRv6Tlv{t, 0, nullptr, 1u};
      pos_ += 1u;
      return true;
    }
 
    // Need at least type + length
    if (pos_ + 2u > len_) {
      return false;
    }
 
    const uint8_t len = ptr_[pos_ + 1u];
    if (static_cast<uint16_t>(pos_ + 2u + len) > len_) {
      return false;
    }
 
    out = SRv6Tlv{t, len, ptr_ + pos_ + 2u, static_cast<uint16_t>(2u + len)};
    pos_ += out.total_len;
    return true;
  }
 
private:
  const uint8_t* ptr_;
  uint16_t len_;
  uint16_t pos_;
};

struct SRv6HmacTlvView {
  const uint8_t* value;
  uint8_t length;
 
  constexpr bool valid() const noexcept { return value && (length >= 6u); }
 
  constexpr bool d_bit() const noexcept {
    if (!valid())
      return false;
 
    uint16_t b = read_from_bytes<uint16_t>(value);
    return ((autoswap(b) >> 15) & 0x1u) != 0u;
  }
 
  constexpr auto key_id() const noexcept -> uint32_t {
    if (!valid())
      return 0u;
 
    uint32_t v = read_from_bytes<uint32_t>(value + 2u);
    return autoswap(v);
  }
 
  constexpr auto hmac() const noexcept -> std::span<const uint8_t> {
    if (!valid())
      return {};
    const uint8_t* p = value + 6u;
    return std::span<const uint8_t>{p, static_cast<uint16_t>(length - 6u)};
  }
};
 
static_assert(sizeof(SRv6Header) == 8, "Wrong SRH header size");
static_assert(alignof(SRv6Header) == 1, "Wrong SRH header alignment");
 
} // namespace vbvx