util.cpp

Go to the documentation of this file.

 
 
#include "profinet/util.h"
 
#include <algorithm>
#include <asio/ip/address_v4.hpp>
#include <cerrno>
#include <cstdio>
#include <cstring>
 
#include "profinet/exceptions.h"
#include "profinet/rt.h"
#include "profinet/wire.h"
 
namespace profinet
{
// =============================================================================
// Byte Conversion Utilities
// =============================================================================
std::string Hex4(std::uint16_t value)
{
  return std::format("0x{:04X}", value);
}
 
std::string Hex2(std::uint8_t value)
{
  return std::format("0x{:02X}", value);
}
 
std::vector<std::uint8_t> ToVec(const std::string& input)
{
  return {input.begin(), input.end()};
}
 
std::string HexFallback(const char* widthPrefix, std::uint32_t value, int digitWidth)
{
  // {}         -> The prefix string
  // {:0{}X}    -> Hexadecimal (X), zero-padded (0), with a dynamic width ({})
  return std::format("{}(0x{:0{}X})", widthPrefix, value, digitWidth);
}
 
// =============================================================================
// Address Conversion Utilities
// =============================================================================
 
std::size_t SkipVlanTags(std::span<const std::uint8_t> frame) noexcept
{
  const std::size_t ethernetHeaderSize = 2U * macAddressLength;
 
  if (frame.size() < ethernetHeaderSize)
  {
    return ethernetHeaderSize;
  }
 
  wire::Reader r(frame);
  r.SkipTo(ethernetHeaderSize);
 
  while (r.Remaining() >= 2U * sizeof(std::uint16_t))
  {
    const std::size_t tpidOffset = r.Position();
 
    // Read 16-bit TPID in network byte order (big-endian)
    const std::uint16_t tpid = r.U16();
 
    // 802.1Q (0x8100), 802.1ad (0x88A8), 802.1Q double-tagging legacy (0x9100)
    if (tpid == rt::ETHERTYPE_VLAN || tpid == rt::ETHERTYPE_VLAN_AD || tpid == rt::ETHERTYPE_VLAN_LEGACY)
    {
      // Skip the 16-bit VLAN TCI.
      r.Skip(sizeof(std::uint16_t));
    }
    else
    {
      // TPID was not a VLAN tag, so return the offset where it starts.
      return tpidOffset;
    }
  }
 
  return r.Position();
}
std::string ToHex(const std::uint8_t* data, std::size_t len)
{
  std::string out;
  out.reserve(len * 2);
  static const char* digits = "0123456789abcdef";
  for (std::size_t i = 0; i < len; ++i)
  {
    out.push_back(digits[data[i] >> 4]);
    out.push_back(digits[data[i] & 0x0F]);
  }
  return out;
}
 
std::string ToHex(const std::vector<std::uint8_t>& data)
{
  return ToHex(data.data(), data.size());
}
 
MacAddress String2Mac(const std::string& macStr)
{
  // Strict structural constants for a standard MAC address
  static constexpr std::size_t expectedStringLength = 17;
  static constexpr std::size_t singleByteHexLength = 2;
  static constexpr int hexBase = 16;
 
  // Explicit array index positions for delimiters
  static constexpr std::array<std::size_t, 5> delimiterIndices = {2, 5, 8, 11, 14};
 
  // Enforce strict total length check
  if (macStr.size() != expectedStringLength)
  {
    throw InvalidMACError(std::format("Invalid MAC address length: '{}'", macStr));
  }
 
  // Validate format
  // We loop through indices from 0 to 16
  bool isValidStructure = true;
  for (std::size_t i = 0; i < expectedStringLength; ++i)
  {
    // Check if current index 'i' matches one of our delimiter positions
    const bool isDelimiterIdx = std::ranges::any_of(delimiterIndices,
                                                    [i](std::size_t d)
    { return d == i; });
 
    if (isDelimiterIdx)
    {
      if (macStr[i] != ':')
      {
        isValidStructure = false;
        break;
      }
    }
    else
    {
      if (std::isxdigit(static_cast<unsigned char>(macStr[i])) == 0)
      {
        isValidStructure = false;
        break;
      }
    }
  }
 
  if (!isValidStructure)
  {
    throw InvalidMACError(std::format("Invalid MAC address characters or format: '{}'", macStr));
  }
 
  MacAddress mac{};
  std::string_view macView{macStr};
 
  // 3. Parse the hex pairs directly into the destination array using string_view
  static constexpr std::size_t hexPairStride = 3; // Length of "xx:" segment
  for (std::size_t i = 0; i < macAddressLength; ++i)
  {
    const std::size_t offset = i * hexPairStride;
    const std::string_view hexPair = macView.substr(offset, singleByteHexLength);
 
    // std::stoul is fully safe here because we pre-validated all digits above
    mac.at(i) = static_cast<std::uint8_t>(std::stoul(std::string(hexPair), nullptr, hexBase));
  }
 
  return mac;
}
 
std::string Mac2String(const MacAddress& mac)
{
  return Mac2String(mac.data(), mac.size());
}
 
std::string Mac2String(const std::uint8_t* macBytes, std::size_t len)
{
  if (len != 6)
  {
    throw InvalidMACError("MAC address must be 6 bytes, got " + std::to_string(len));
  }
  // Extract the formatted MAC address into a dedicated string variable
  const std::string macStr = std::format("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
                                         macBytes[0], macBytes[1], macBytes[2],
                                         macBytes[3], macBytes[4], macBytes[5]);
  return macStr;
}
 
std::string String2Ip(std::span<const std::uint8_t> ipBytes)
{
  if (ipBytes.size() < 4)
  {
    throw InvalidIPError("IP address must be at least 4 bytes, got " + std::to_string(ipBytes.size()));
  }
 
  return std::to_string(ipBytes[0]) + "." + std::to_string(ipBytes[1]) + "." +
         std::to_string(ipBytes[2]) + "." + std::to_string(ipBytes[3]);
}
 
std::string String2Ip(const std::uint8_t* ipBytes, std::size_t len)
{
  return String2Ip(std::span<const std::uint8_t>(ipBytes, len));
}
 
std::array<std::uint8_t, 4> Ip2String(const std::string& ipStr)
{
  if (ipStr.empty())
  {
    throw InvalidIPError("IP address cannot be empty");
  }
 
  asio::error_code ec;
  const auto address = asio::ip::make_address_v4(ipStr, ec);
 
  if (ec)
  {
    throw InvalidIPError("Invalid IP address: '" + ipStr + "'");
  }
 
  const auto bytes = address.to_bytes();
 
  return {
      bytes[0],
      bytes[1],
      bytes[2],
      bytes[3]};
}
 
std::string DecodeBytes(const std::uint8_t* data, std::size_t len)
{
  std::size_t end = len;
  while (end > 0 && data[end - 1] == 0)
  {
    --end;
  }
  // NOLINTNEXTLINE(modernize-return-braced-init-list)
  return std::string(reinterpret_cast<const char*>(data), end);
}
 
std::string DecodeBytes(const std::vector<std::uint8_t>& data)
{
  return DecodeBytes(data.data(), data.size());
}
 
// =============================================================================
// Platform Network Utilities
// =============================================================================
 
MacAddress MacAddressProvider::GetMac(const std::string& interface)
{
  return GetInterfaceMac(interface);
}
} // namespace profinet