util.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <span>
#include <string>
#include <vector>
 
#include "profinet/IRawEthernetSocket.h"
 
namespace profinet
{
 
// =============================================================================
// Constants
// =============================================================================
 
// NOLINTBEGIN(readability-identifier-naming)
inline constexpr std::size_t MAX_ETHERNET_FRAME = 1522;
inline constexpr std::uint16_t PROFINET_ETHERTYPE = 0x8892;
inline constexpr std::uint16_t IP_ETHERTYPE = 0x8000;
inline constexpr std::uint16_t VLAN_ETHERTYPE = 0x8100;
inline constexpr int ETH_P_ALL = 0x0003;
 
inline constexpr int macAddressLength = 6;
 
inline constexpr int uuidLenght = 16;
 
// @brief The number of bits in a single octet (byte), used as the base for network byte order shifts.
static constexpr int BitsPerOctet = 8;
 
static constexpr int OneOctetShift = BitsPerOctet; // Automatically 8
 
static constexpr int TwoOctetsShift = BitsPerOctet * 2; // Automatically 16
 
static constexpr int ThreeOctetsShift = BitsPerOctet * 3; // Automatically 24
 
static constexpr std::uint8_t LowByteMask = 0xFF;
 
inline constexpr std::size_t RECEIVE_BUFFER_LENGTH = 4096;
 
// NOLINTEND(readability-identifier-naming)
 
using MacAddress = std::array<std::uint8_t, macAddressLength>;
 
// =============================================================================
// Byte Conversion Utilities
// =============================================================================
 
std::string Hex4(std::uint16_t value);
 
std::string Hex2(std::uint8_t value);
 
std::vector<std::uint8_t> ToVec(const std::string& input);
 
std::string HexFallback(const char* widthPrefix, std::uint32_t value, int digitWidth);
// =============================================================================
// Address Conversion Utilities
// =============================================================================
 
std::size_t SkipVlanTags(std::span<const std::uint8_t> frame) noexcept;
 
std::string ToHex(const std::uint8_t* data, std::size_t len);
 
std::string ToHex(const std::vector<std::uint8_t>& data);
 
MacAddress String2Mac(const std::string& macStr);
 
std::string Mac2String(const MacAddress& mac);
 
std::string Mac2String(const std::uint8_t* macBytes, std::size_t len);
 
std::string String2Ip(std::span<const std::uint8_t> ipBytes);
 
std::string String2Ip(const std::uint8_t* ipBytes, std::size_t len);
 
std::array<std::uint8_t, 4> Ip2String(const std::string& ipStr);
 
std::string DecodeBytes(const std::uint8_t* data, std::size_t len);
 
std::string DecodeBytes(const std::vector<std::uint8_t>& data);
 
// =============================================================================
// Socket Utilities (Linux AF_PACKET)
// =============================================================================
 
MacAddress GetMac(const std::string& ifname);
 
std::filesystem::path GetExecutableDirectory();
 
class EthernetSocket : public IRawEthernetSocket
{
 public:
  explicit EthernetSocket(const std::string& interface, std::uint16_t ethertype = 0);
 
  ~EthernetSocket();
 
  EthernetSocket(const EthernetSocket&) = delete;
 
  EthernetSocket& operator=(const EthernetSocket&) = delete;
 
  EthernetSocket(EthernetSocket&& other) noexcept;
 
  EthernetSocket& operator=(EthernetSocket&& other) noexcept;
 
  void Send(const std::vector<std::uint8_t>& frame) const override;
 
  void SetTimeout(std::chrono::milliseconds timeout) const override;
 
  [[nodiscard]] std::vector<std::uint8_t> Recv() const override;
 
  [[nodiscard]] int Fd() const
  {
    return fd;
  }
 
 private:
  int fd = -1;
};
 
class UdpSocket
{
 public:
  static constexpr double defaultTimeout = 5.0;
 
  static constexpr int defaultReceiveBufferSize = 65536;
 
  UdpSocket(const std::string& host, std::uint16_t port,
            std::chrono::duration<double> timeout = std::chrono::duration<double>(defaultTimeout));
 
  ~UdpSocket();
 
  UdpSocket(const UdpSocket&) = delete;
 
  UdpSocket& operator=(const UdpSocket&) = delete;
 
  UdpSocket(UdpSocket&& other) noexcept;
 
  UdpSocket& operator=(UdpSocket&& other) noexcept;
 
  void Send(const std::vector<std::uint8_t>& data) const;
 
  [[nodiscard]] std::vector<std::uint8_t> Recv(std::size_t maxLen = defaultReceiveBufferSize) const;
 
  [[nodiscard]] int Fd() const
  {
    return fd;
  }
 
 private:
  int fd = -1;
};
 
// =============================================================================
// Timeout helper
// =============================================================================
 
class MaxTimeout
{
 public:
  explicit MaxTimeout(std::chrono::duration<double> seconds)
      : dieAfter(std::chrono::steady_clock::now() +
                 std::chrono::duration_cast<std::chrono::steady_clock::duration>(seconds))
  {
  }
 
  [[nodiscard]] bool TimedOut() const
  {
    return std::chrono::steady_clock::now() > dieAfter;
  }
 
  [[nodiscard]] std::chrono::duration<double> Remaining() const
  {
    auto rem = dieAfter - std::chrono::steady_clock::now();
    auto secs = std::chrono::duration<double>(rem);
    return secs.count() > 0 ? secs : std::chrono::duration<double>(0);
  }
 
 private:
  std::chrono::steady_clock::time_point dieAfter;
};
 
} // namespace profinet