rpc.cpp

Go to the documentation of this file.

 
 
#include "profinet/rpc.h"
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <random>
#include <ranges>
#include <sstream>
 
#include "profinet/cyclic.h"
 
namespace profinet::rpc
{
 
namespace
{
 
std::array<std::uint8_t, uuidLenght> RandomUuidBytes()
{
  static thread_local std::mt19937 rng{std::random_device{}()};
  static constexpr int maxByteValue = 255;
  static thread_local std::uniform_int_distribution<int> dist(0, maxByteValue);
  std::array<std::uint8_t, uuidLenght> out{};
  for (auto& b : out)
  {
    b = static_cast<std::uint8_t>(dist(rng));
  }
  return out;
}
 
std::uint16_t RandomNonzeroU16()
{
  static thread_local std::mt19937 rng{std::random_device{}()};
 
  static constexpr int maxU16Value = 0xFFFF;
  static thread_local std::uniform_int_distribution<int> dist(0, maxU16Value);
  const int v = dist(rng);
  return static_cast<std::uint16_t>(v == 0 ? 1 : v);
}
 
} // namespace
 
// =============================================================================
// UUID helpers
// =============================================================================
std::array<std::uint8_t, uuidLenght> BuildObjectUuid(std::uint8_t b10, std::uint8_t b11, std::uint8_t b12, std::uint8_t b13,
                                                     std::uint8_t b14, std::uint8_t b15)
{
  // OBJECT_UUID_PREFIX (10 bytes, per protocol.h): DE A0 00 00 + first 6
  // bytes of the shared PROFINET UUID suffix (6C 97 11 D1 82 71).
 
  // Protocol constant hex values for the header
  static constexpr std::uint8_t pnPrefixByte0 = 0xDE;
  static constexpr std::uint8_t pnPrefixByte1 = 0xA0;
  static constexpr std::uint8_t pnPrefixByte2 = 0x00;
  static constexpr std::uint8_t pnPrefixByte3 = 0x00;
 
  // UUID field indices mapped to official UUID structure
  static constexpr std::size_t uuidIdxTimeLow0 = 0;
  static constexpr std::size_t uuidIdxTimeLow1 = 1;
  static constexpr std::size_t uuidIdxTimeLow2 = 2;
  static constexpr std::size_t uuidIdxTimeLow3 = 3;
 
  static constexpr std::size_t uuidIdxTimeMid0 = 4;
  static constexpr std::size_t suffixBytesToCopy = 6;
 
  static constexpr std::size_t uuidIdxNode0 = 10;
  static constexpr std::size_t uuidIdxNode1 = 11;
  static constexpr std::size_t uuidIdxNode2 = 12;
  static constexpr std::size_t uuidIdxNode3 = 13;
  static constexpr std::size_t uuidIdxNode4 = 14;
  static constexpr std::size_t uuidIdxNode5 = 15;
 
  std::array<std::uint8_t, uuidLenght> objectUuid{};
 
  // Write the fixed 4-byte PROFINET protocol prefix (into time_low)
  objectUuid[uuidIdxTimeLow0] = pnPrefixByte0;
  objectUuid[uuidIdxTimeLow1] = pnPrefixByte1;
  objectUuid[uuidIdxTimeLow2] = pnPrefixByte2;
  objectUuid[uuidIdxTimeLow3] = pnPrefixByte3;
 
  // Copy the 6-byte shared suffix (populates time_mid, time_hi, and clock_seq)
  std::ranges::copy(kPnUuidSuffix | std::views::take(suffixBytesToCopy),
                    (objectUuid | std::views::drop(uuidIdxTimeMid0)).begin());
 
  // Populate the trailing 6 unique bytes (populates node ID)
  objectUuid[uuidIdxNode0] = b10;
  objectUuid[uuidIdxNode1] = b11;
  objectUuid[uuidIdxNode2] = b12;
  objectUuid[uuidIdxNode3] = b13;
  objectUuid[uuidIdxNode4] = b14;
  objectUuid[uuidIdxNode5] = b15;
 
  return objectUuid;
}
std::string UuidBytesToString(const std::array<std::uint8_t, uuidLenght>& data)
{
  wire::Reader r(data);
  // DCE/RPC UUIDs use mixed byte order:
  // time_low, time_mid and time_hi_and_version are little-endian
  // clock sequence and node are big-endian.
  const std::uint32_t timeLow = r.U32LittleEndian();
  const std::uint16_t timeMid = r.U16LittleEndian();
  const std::uint16_t timeHi = r.U16LittleEndian();
  const std::uint16_t clockSeq = r.U16();
 
  const auto node = r.Fixed<6U>();
 
  // Format the first tracking segments and cleanly append the remaining hex data
  const std::string out = std::format("{:08x}-{:04x}-{:04x}-{:04x}-{}",
                                      timeLow, timeMid, timeHi, clockSeq,
                                      ToHex(node.data(), node.size()));
  return out;
}
 
std::array<std::uint8_t, uuidLenght> StringToUuidBytes(const std::string& uuidStr)
{
  // UUID Structural Constants
  static constexpr std::size_t expectedHexLength = 32;
  static constexpr int hexBase = 16;
  static constexpr std::size_t singleByteHexLength = 2;
 
  // Component Substring Offsets and Lengths
  static constexpr std::size_t timeLowOffset = 0U;
  static constexpr std::size_t timeLowLength = 8U;
 
  static constexpr std::size_t timeMidOffset = 8U;
  static constexpr std::size_t timeMidLength = 4U;
 
  static constexpr std::size_t timeHiOffset = 12U;
  static constexpr std::size_t timeHiLength = 4U;
 
  static constexpr std::size_t clockSeqOffset = 16U;
  static constexpr std::size_t clockSeqLength = 4U;
 
  static constexpr std::size_t nodeDataStartHexOffset = 20;
 
  std::string hex;
  hex.reserve(expectedHexLength);
  for (const char c : uuidStr)
  {
    if (c != '-')
    {
      hex.push_back(c);
    }
  }
 
  if (hex.size() != expectedHexLength)
  {
    throw std::invalid_argument("Invalid UUID string: " + uuidStr);
  }
 
  // Helper lambda to parse character hex into a bytes
  auto parseValue = [&hex](std::size_t offset, std::size_t length) -> std::uint32_t
  {
    auto hexString = hex.substr(offset, length);
    auto hexLong = std::stoul(hexString, nullptr, hexBase);
    return static_cast<std::uint32_t>(hexLong);
  };
 
  const std::uint32_t timeLow = parseValue(timeLowOffset, timeLowLength);
  const std::uint16_t timeMid = static_cast<std::uint16_t>(parseValue(timeMidOffset, timeMidLength));
  const std::uint16_t timeHi = static_cast<std::uint16_t>(parseValue(timeHiOffset, timeHiLength));
  const std::uint16_t clockSeq = static_cast<std::uint16_t>(parseValue(clockSeqOffset, clockSeqLength));
 
  Bytes out{};
  out.reserve(uuidLenght);
 
  // DCE/RPC UUID: first three fields are little-endian.
  wire::PutLittleEndian(out, timeLow);
  wire::PutLittleEndian(out, timeMid);
  wire::PutLittleEndian(out, timeHi);
 
  // DCE/RPC UUID: clock sequence is big-endian.
  wire::PutBigEndian(out, clockSeq);
 
  // Node ID is six raw bytes and has no integer byte-order conversion.
  for (std::size_t i = 0U; i < 6U; ++i)
  {
    auto hexString = hex.substr(nodeDataStartHexOffset + i * singleByteHexLength, singleByteHexLength);
    auto hexLong = std::stoul(hexString, nullptr, hexBase);
    const auto nodeByte = static_cast<std::uint8_t>(hexLong);
    out.push_back(nodeByte);
  }
 
  if (out.size() != uuidLenght)
  {
    throw std::logic_error("UUID serialization produced an invalid size");
  }
 
  std::array<std::uint8_t, uuidLenght> result{};
  std::ranges::copy(out, result.begin());
 
  return result;
}
 
// =============================================================================
// EPM
// =============================================================================
 
std::string EPMEndpoint::InterfaceName() const
{
  std::string lower = interfaceUuid;
  std::ranges::transform(lower, lower.begin(), ::tolower);
 
  if (lower == UUID_PNIO_DEVICE)
  {
    return "PNIO-Device";
  }
  if (lower == UUID_PNIO_CONTROLLER)
  {
    return "PNIO-Controller";
  }
  if (lower == UUID_PNIO_SUPERVISOR)
  {
    return "PNIO-Supervisor";
  }
  if (lower == UUID_PNIO_PARAMETER_SERVER)
  {
    return "PNIO-ParameterServer";
  }
  if (lower == UUID_EPM_V4)
  {
    return "EPM";
  }
  return "Unknown(" + interfaceUuid + ")";
}
 
std::optional<EPMEndpoint> ParseEpmTower(const Bytes& towerData)
{
  if (towerData.size() < sizeof(std::uint16_t))
  {
    return std::nullopt;
  }
 
  wire::Reader r(towerData);
  const auto floorCount = r.U16LittleEndian();
 
  EPMEndpoint endpoint;
 
  for (std::uint16_t floorIdx = 0; floorIdx < floorCount; ++floorIdx)
  {
    if (r.Remaining() < 2U * sizeof(std::uint16_t))
    {
      break;
    }
 
    const auto lhsLen = r.U16LittleEndian();
 
    if (r.Remaining() < lhsLen + sizeof(std::uint16_t))
    {
      break;
    }
 
    const Bytes lhsData = r.ReadBytes(lhsLen);
 
    const auto rhsLen = r.U16LittleEndian();
 
    if (r.Remaining() < rhsLen)
    {
      break;
    }
 
    const Bytes rhsData = r.ReadBytes(rhsLen);
 
    if (lhsLen < 1U)
    {
      continue;
    }
 
    const std::uint8_t protocolId = lhsData[0];
 
    if (protocolId == 0x0D && lhsLen >= 19U)
    {
      if (floorIdx == 0U)
      {
        wire::Reader lhsReader(lhsData);
        lhsReader.SkipTo(1U);
 
        const auto uuidBytes = lhsReader.Fixed<uuidLenght>();
        endpoint.interfaceUuid = UuidBytesToString(uuidBytes);
 
        lhsReader.SkipTo(1U + uuidLenght);
        endpoint.interfaceVersionMajor = lhsReader.U16LittleEndian();
 
        if (rhsLen >= sizeof(std::uint16_t))
        {
          wire::Reader rhsReader(rhsData);
          endpoint.interfaceVersionMinor = rhsReader.U16LittleEndian();
        }
      }
    }
    else if (protocolId == 0x0A)
    {
      endpoint.protocol = "ncadg_ip_udp";
    }
    else if (protocolId == 0x08 && rhsLen >= sizeof(std::uint16_t))
    {
      wire::Reader rhsReader(rhsData);
      endpoint.port = rhsReader.U16();
    }
    else if (protocolId == 0x09 && rhsLen >= 4U)
    {
      endpoint.ipAddress =
          std::to_string(rhsData[0]) + "." +
          std::to_string(rhsData[1]) + "." +
          std::to_string(rhsData[2]) + "." +
          std::to_string(rhsData[3]);
    }
  }
 
  if (endpoint.interfaceUuid.empty())
  {
    return std::nullopt;
  }
 
  return endpoint;
}
 
std::vector<EPMEndpoint> RPCCon::EpmLookup(const std::string& ip, std::uint16_t port, double timeoutSec,
                                           std::optional<std::string> interfaceFilter)
{
  std::vector<EPMEndpoint> results;
 
  RpcTransport transport(ioContext);
 
  transport.Open(ip, port);
 
  // Build little-endian RPC header (kFixedSize, 80 bytes).
  auto activityUuidArr = RandomUuidBytes();
  Bytes activityUuidBytes(activityUuidArr.begin(), activityUuidArr.end());
  auto objectUuidBytes = std::array<std::uint8_t, uuidLenght>{}; // NULL object UUID
  auto interfaceUuidBytes = StringToUuidBytes(UUID_EPM_V4);
 
  Bytes header;
  header.push_back(4);                    // version
  header.push_back(PNRPCHeader::REQUEST); // packet_type = REQUEST, 0x00
  auto flags1 = static_cast<std::uint8_t>(raw::Flags1::Idempotent);
  header.push_back(flags1); // flags1
  header.push_back(0x00);   // flags2
  header.push_back(raw::RawRpcHeader::kLittleEndianDrepFlag);
  header.push_back(0x00);
  header.push_back(0x00); // drep (little-endian)
  header.push_back(0);    // serial_high
  wire::PutFixed(header, objectUuidBytes);
  wire::PutFixed(header, interfaceUuidBytes);
  wire::PutFixed(header, activityUuidBytes);
 
  wire::PutLittleEndian<std::uint32_t>(header, 0); // server boot time
  wire::PutLittleEndian<std::uint32_t>(header, 3); // interface version
  wire::PutLittleEndian<std::uint32_t>(header, 0); // sequence number
 
  wire::PutLittleEndian<std::uint16_t>(header, EPM_LOOKUP);
 
  wire::PutLittleEndian(header, PNRPCHeader::defaultInterfaceHint); // interface hint
  wire::PutLittleEndian(header, PNRPCHeader::defaultActivityHint);  // activity hint
 
  const std::size_t lengthOfBodyOffset = header.size();
  wire::PutLittleEndian<std::uint16_t>(header, 0); // length_of_body placeholder, patched below
  wire::PutLittleEndian<std::uint16_t>(header, 0); // fragment_number
 
  header.push_back(0); // authentication_protocol
  header.push_back(0); // serial_low
 
  const std::uint32_t inquiryType = interfaceFilter ? EPM_INQUIRY_INTERFACE : EPM_INQUIRY_ALL;
  Bytes body;
  wire::PutLittleEndian(body, inquiryType);
  if (interfaceFilter)
  {
    auto ifaceBytes = StringToUuidBytes(*interfaceFilter);
    body.insert(body.end(), ifaceBytes.begin(), ifaceBytes.end());
    wire::PutLittleEndian<std::uint16_t>(body, 1);
    wire::PutLittleEndian<std::uint16_t>(body, 0);
  }
  else
  {
    body.insert(body.end(), uuidLenght, 0);
    wire::PutLittleEndian<std::uint16_t>(body, 0);
    wire::PutLittleEndian<std::uint16_t>(body, 0);
  }
  wire::PutLittleEndian<std::uint32_t>(body, 0); // vers option
  wire::PutLittleEndian<std::uint32_t>(body, 0); // entry handle
  constexpr std::uint32_t maxEnts = 100U;
  wire::PutLittleEndian(body, maxEnts); // max ents
 
  wire::PutLittleEndian<std::uint16_t>(header.data() + lengthOfBodyOffset, body.size());
  // header was built with a 2-byte placeholder at lengthOfBodyOffset and
  // is already exactly 80 bytes (the fixed RPC header size); no resize needed.
 
  Bytes request = header;
  request.insert(request.end(), body.begin(), body.end());
 
  auto timeoutInMilliSeconds = std::chrono::floor<std::chrono::milliseconds>(std::chrono::duration<double>(timeoutSec));
  Bytes data = transport.SendReceive(request, timeoutInMilliSeconds);
 
  if (data.size() < PNRPCHeader::kFixedSize)
  {
    return results;
  }
  // data.resize(static_cast<std::size_t>(n));
 
  const std::uint8_t respType = data[1];
  if (respType == 0x03 || respType != 0x02)
  {
    return results; // FAULT or not RESPONSE
  }
  wire::Reader r(data);
  constexpr std::uint16_t kBodyLenIndex = 74U;
  r.SkipTo(kBodyLenIndex);
 
  std::uint16_t bodyLen = r.U16LittleEndian();
  if (data.size() < PNRPCHeader::kFixedSize + static_cast<std::size_t>(bodyLen))
  {
    bodyLen = static_cast<std::uint16_t>(data.size() - PNRPCHeader::kFixedSize);
  }
  Bytes bodyData(data.begin() + PNRPCHeader::kFixedSize, data.begin() + PNRPCHeader::kFixedSize + bodyLen);
  if (bodyData.size() < 12)
  {
    return results;
  }
 
  std::size_t offset = sizeof(std::uint32_t); // skip entry_handle
  wire::Reader b(bodyData);
 
  b.SkipTo(offset);
  const std::uint32_t numEnts = b.U32LittleEndian();
  offset += sizeof(std::uint32_t);
 
  offset += 3U * sizeof(std::uint32_t); // max_count, offset, actual_count
 
  for (std::uint32_t i = 0; i < numEnts; ++i)
  {
    if (offset + uuidLenght > bodyData.size())
    {
      break;
    }
    b.SkipTo(offset);
    const auto entryUuidBytes = b.Fixed<uuidLenght>();
 
    const std::string entryObjectUuid = UuidBytesToString(entryUuidBytes);
    offset += uuidLenght;
 
    if (bodyData.size() < offset + sizeof(std::uint32_t))
    {
      break;
    }
    offset += sizeof(std::uint32_t); // tower p pointer
 
    if (bodyData.size() < offset + sizeof(std::uint32_t))
    {
      break;
    }
    b.SkipTo(offset);
    const std::uint32_t annotationLen = b.U32LittleEndian();
    offset += sizeof(std::uint32_t);
 
    std::string annotation;
    if (annotationLen > 0 && offset + annotationLen <= bodyData.size())
    {
      const std::size_t end = offset + annotationLen;
      std::size_t trim = end;
      while (trim > offset && bodyData[trim - 1] == 0)
      {
        --trim;
      }
      annotation = std::string(bodyData.begin() + offset, bodyData.begin() + trim);
    }
    offset += annotationLen;
    offset = (offset + 3) & ~static_cast<std::size_t>(3);
 
    if (offset + 4 > bodyData.size())
    {
      break;
    }
    b.SkipTo(offset);
    const auto towerLen = b.U32LittleEndian();
    offset += sizeof(std::uint32_t);
 
    if (bodyData.size() < offset + towerLen)
    {
      break;
    }
    const Bytes towerData(bodyData.begin() + offset, bodyData.begin() + offset + towerLen);
    offset += towerLen;
    offset = (offset + 3) & ~static_cast<std::size_t>(3);
 
    auto endpoint = ParseEpmTower(towerData);
    if (endpoint)
    {
      endpoint->objectUuid = entryObjectUuid;
      endpoint->annotation = annotation;
      results.push_back(*endpoint);
    }
  }
 
  return results;
}
 
dcp::DCPDeviceDescription GetStationInfo(IRawEthernetSocket& sock,
                                         const MacAddress& src,
                                         const std::string& name,
                                         double timeoutSec)
{
  dcp::SendRequest(sock, src, dcp::MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::NAME_OF_STATION.first), PNDCPBlock::NAME_OF_STATION.second),
                   Bytes(name.begin(), name.end()));
  auto responses = dcp::ReadResponse(sock, src, timeoutSec, /*once=*/true);
 
  if (responses.empty())
  {
    dcp::SendDiscover(sock, src);
    responses = dcp::ReadResponse(sock, src, timeoutSec);
    for (const auto& [Mac, Blocks] : responses)
    {
      dcp::DCPDeviceDescription desc(Mac, Blocks);
      std::string lowerDescName = desc.name;
      std::string lowerTarget = name;
      std::ranges::transform(lowerDescName, lowerDescName.begin(), ::tolower);
      std::ranges::transform(lowerTarget, lowerTarget.begin(), ::tolower);
      if (lowerDescName == lowerTarget)
      {
        return desc;
      }
    }
    throw DCPDeviceNotFoundError("Device with name '" + name + "' not found");
  }
 
  const auto& [Mac, Blocks] = *responses.begin();
  // NOLINTNEXTLINE(modernize-return-braced-init-list)
  return dcp::DCPDeviceDescription(Mac, Blocks);
}
 
// =============================================================================
// IOCRSetup
// =============================================================================
 
std::vector<std::string> IOCRSetup::Validate() const
{
  std::vector<std::string> warnings;
  const double cycleMs = CycleTimeMs();
  if (cycleMs < 1)
  {
    warnings.emplace_back("Cycle time too fast - sub-1ms is impractical without hardware support");
  }
  else if (cycleMs < cyclic::MIN_CYCLE_MS)
  {
    warnings.emplace_back("Cycle time may cause jitter (8ms+ recommended)");
  }
  if (watchdogFactor < 3)
  {
    warnings.emplace_back("Watchdog factor too low (use 6+)");
  }
  if (slots.empty())
  {
    warnings.emplace_back("No IO slots configured");
  }
  return warnings;
}
 
// =============================================================================
// RPCCon
// =============================================================================
 
RPCCon::RPCCon(const dcp::DCPDeviceDescription& info, RPCConOptions options,
               std::unique_ptr<IRpcTransport> rpcTransport,
               std::unique_ptr<IRpcTransport> ccontrolTransport,
               asio::io_context* context)
    : info(info),
      timeout(options.timeoutSec),
      sessionKey(RandomNonzeroU16()),
      rpcContext(context ? nullptr : std::make_unique<asio::io_context>()),
      rpcContextRunner(context ? nullptr : std::make_unique<AsioIoContextRunner>(*rpcContext)), // use this only when not called
      ioContext(context ? *context : *rpcContext),
      rpcTransport(std::move(rpcTransport)),
      ccontrolTransport(std::move(ccontrolTransport))
{
  if (this->rpcTransport == nullptr)
  {
    this->rpcTransport = std::make_unique<RpcTransport>(ioContext);
  }
  if (this->ccontrolTransport == nullptr)
  {
    this->ccontrolTransport = std::make_unique<RpcTransport>(ioContext);
  }
 
  arUuid = RandomUuidBytes();
  activityUuid = RandomUuidBytes();
  interfaceUuid = PNRPCHeader::IfaceUuidDevice();
 
  localObjectUuid = BuildObjectUuid(0x00, 0x01, 0x76, 0x54, 0x32, 0x10);
  remoteObjectUuid =
      BuildObjectUuid(0x00, 0x01, info.deviceHigh, info.deviceLow, info.vendorHigh, info.vendorLow);
 
  this->rpcTransport->Open(info.ip, options.rpcPort);
  const std::string anyIp = asio::ip::address_v4::any().to_string();
 
  // Fixed listener: 34964 -> 0x8894.
  this->ccontrolTransport->Open(anyIp, RPC_PORT, true);
}
 
RPCCon::~RPCCon()
{
  Close();
}
 
PNRPCHeader RPCCon::CreateRpc(std::uint16_t operation, const Bytes& nrd)
{
  PNRPCHeader h;
  h.version = 4;
  h.packetType = PNRPCHeader::REQUEST;
  h.flags1 = static_cast<std::uint8_t>(raw::Flags1::Idempotent);
  h.flags2 = 0x00;
  h.dataRepresentation = {0x00, 0x00, 0x00};
  h.serialNrHigh = 0;
  h.objectUuid = remoteObjectUuid;
  h.interfaceUuid = interfaceUuid;
  h.activityUuid = activityUuid;
  h.serverBootTime = 0;
  h.interfaceVersion = 1;
  h.sequenceNumber = sequenceNumber++;                     // drep?
  h.operationNumber = operation;                           // drep?
  h.interfaceHint = PNRPCHeader::defaultInterfaceHint;     // drep?
  h.activityHint = PNRPCHeader::defaultActivityHint;       // drep?
  h.lengthOfBody = static_cast<std::uint16_t>(nrd.size()); // drep?
  h.fragmentNumber = 0;                                    // drep?
  h.authenticationProtocol = 0;                            // drep?
  h.serialNrLow = 0;                                       // drep?
  h.payload = nrd;
  return h;
}
 
PNNRDData RPCCon::CreateNrd(const Bytes& payload)
{
  PNNRDData nrd;
  nrd.argsMaximumStatus = 1500;
  nrd.argsLength = static_cast<std::uint32_t>(payload.size());
  nrd.maximumCount = 1500;
  nrd.offset = 0;
  nrd.actualCount = static_cast<std::uint32_t>(payload.size());
  nrd.payload = payload;
  return nrd;
}
 
Bytes RPCCon::BuildAlarmCrBlock(int transport, int priority) const
{
  auto properties = static_cast<std::uint32_t>((transport << 1) | priority);
 
  PNBlockHeader header;
  header.blockType = PNAlarmCRBlockReq::BLOCK_TYPE;
  header.blockLength = static_cast<std::uint16_t>(PNAlarmCRBlockReq::kSize - 4);
  header.blockVersionHigh = VERSION_HIGH;
  header.blockVersionLow = VERSION_LOW;
 
  PNAlarmCRBlockReq alarmCr;
  std::ranges::copy(header.ToBytes() | std::views::take(blockHeaderLength), alarmCr.blockHeader.begin());
 
  alarmCr.alarmCrType = 0x0001;
  alarmCr.etherTypeLT = transport == 0 ? PROFINET_ETHERTYPE : IP_ETHERTYPE;
  alarmCr.alarmCrProperties = properties;
  alarmCr.rtaTimeoutFactor = PNAlarmCRBlockReq::DEFAULT_RTA_TIMEOUT_FACTOR;
  alarmCr.rtaRetries = PNAlarmCRBlockReq::DEFAULT_RTA_RETRIES;
  alarmCr.localAlarmReference = alarmRef;
  alarmCr.maxAlarmDataLength = PNAlarmCRBlockReq::DEFAULT_MAX_ALARM_DATA_LENGTH;
  alarmCr.alarmCrTagHeaderHigh = PNAlarmCRBlockReq::DEFAULT_TAG_HEADER_HIGH;
  alarmCr.alarmCrTagHeaderLow = PNAlarmCRBlockReq::DEFAULT_TAG_HEADER_LOW;
 
  return alarmCr.ToBytes();
}
 
int RPCCon::ParseAlarmCrResponse(const Bytes& responseData)
{
  std::size_t offset = 0;
  while (offset + blockHeaderLength <= responseData.size())
  {
    auto hdr = PeekBlockHeader(responseData, offset);
    const std::size_t blockSize = 4 + hdr.blockLength;
 
    if (offset + blockSize > responseData.size())
    {
      break;
    }
    if (hdr.blockType == PNAlarmCRBlockRes::BLOCK_TYPE)
    {
      const Bytes blockBytes(
          responseData.begin() + offset,
          responseData.begin() + offset + blockSize);
      auto res = PNAlarmCRBlockRes::Parse(blockBytes);
      return res.localAlarmReference;
    }
    offset += 4 + hdr.blockLength;
  }
  return -1;
}
Bytes RPCCon::BuildIocrBlock(IocrType iocrType, const IOCRSetup& setup)
{
  // ===========================================================================
  // Build the IOCR from the resolved IO configuration.
  //
  // IOCRSetup::slots is the canonical resolved configuration produced by
  // BuildIoSlots().
  //
  // The two IOSlot flags determine whether a slot participates in the
  // corresponding IOCR:
  //
  //   inputIocrObject  -> Input CR
  //   outputIocrObject -> Output CR
  //
  // Within an IOCR:
  //
  //   INPUT CR:
  //       inputIocrObject  -> IODataObject
  //       outputIocrObject -> IOCSObject
  //
  //   OUTPUT CR:
  //       outputIocrObject -> IODataObject
  //       inputIocrObject  -> IOCSObject
  //
  // This deliberately contains no knowledge of AUMA, Phoenix, slot numbers,
  // subslot numbers, module identifiers, or application data sizes.
  // ===========================================================================
 
  if (iocrType != IocrType::Input && iocrType != IocrType::Output)
  {
    throw std::invalid_argument("BuildIocrBlock: unsupported IOCR type " + std::string(magic_enum::enum_name(iocrType)));
  }
 
  // ---------------------------------------------------------------------------
  // Collect IOData and IOCS objects.
  //
  // We keep the objects in the same order as setup.slots. This is important:
  // BuildIoSlots() defines the resolved configuration order, and therefore
  // also defines the deterministic wire representation.
  // ---------------------------------------------------------------------------
 
  std::vector<IOCRAPIObject> ioDataObjects;
  std::vector<IOCRAPIObject> iocsObjects;
 
  std::uint16_t frameOffset = 0;
  std::uint16_t dapOffset = 0;
  std::uint16_t processByteLength = 0;
  for (const IOSlot& slot : setup.slots)
  {
    std::cerr
        << "IO slot "
        << slot.slot << "/"
        << std::hex << slot.subslot << std::dec
        << " in=" << slot.inputLength
        << " out=" << slot.outputLength
        << '\n';
 
    if (iocrType == IocrType::Input)
    {
      if ((slot.inputLength >= 0 && slot.outputLength == 0) || (slot.inputLength > 0 && slot.outputLength > 0))
      {
        ioDataObjects.push_back({.slotNumber = slot.slot, .subslotNumber = slot.subslot, .frameOffset = frameOffset});
        processByteLength = slot.inputLength;
        frameOffset++;
        frameOffset += slot.inputLength;
      }
 
      if (slot.outputLength > 0)
      {
        iocsObjects.push_back({.slotNumber = slot.slot, .subslotNumber = slot.subslot, .frameOffset = frameOffset});
        frameOffset++;
      }
    }
    else
    {
      if ((slot.inputLength >= 0 && slot.outputLength == 0) || (slot.inputLength > 0 && slot.outputLength > 0))
      {
        iocsObjects.push_back({.slotNumber = slot.slot, .subslotNumber = slot.subslot, .frameOffset = frameOffset});
        processByteLength = slot.outputLength;
        frameOffset++;
      }
      if (slot.outputLength > 0)
      {
        ioDataObjects.push_back({.slotNumber = slot.slot, .subslotNumber = slot.subslot, .frameOffset = frameOffset});
        frameOffset++;
        frameOffset += slot.outputLength;
      }
    }
  }
 
  // ---------------------------------------------------------------------------
  // Correct the frameOffset
  // ---------------------------------------------------------------------------
  const std::uint16_t numberOfIocsBytes = iocsObjects.size();
  const std::uint16_t numberOfIopsBytes = ioDataObjects.size();
 
  const std::uint16_t dataLength = numberOfIocsBytes + processByteLength + numberOfIopsBytes;
  /*
  if (iocrType == IocrType::Input)
  {
    std::uint16_t dapModuleOffset = dataLength - dapOffset;
    std::uint16_t ioModuleOffset = 0;
 
    for (const IOSlot& slot : setup.slots)
    {
      if (slot.inputLength == 0 && slot.outputLength == 0)
      {
        auto it = std::ranges::find_if(ioDataObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == ioDataObjects.end())
        {
          continue;
        }
        it->frameOffset = dapModuleOffset;
        dapModuleOffset++;
      }
      if (slot.inputLength > 0)
      {
        auto it = std::ranges::find_if(ioDataObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == ioDataObjects.end())
        {
          continue;
        }
        if (frameOffset != 0)
        {
          frameOffset--;
        }
        it->frameOffset = frameOffset;
      }
      if (slot.outputLength > 0)
      {
        auto it = std::ranges::find_if(iocsObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == iocsObjects.end())
        {
          continue;
        }
        if (frameOffset != 0)
        {
          frameOffset--;
        }
        it->frameOffset = frameOffset;
      }
    }
  }
  else
  {
    std::uint16_t dapModuleOffset = dataLength - dapOffset;
    std::uint16_t ioModuleOffset = 0;
 
    for (const IOSlot& slot : setup.slots)
    {
      if (slot.inputLength == 0 && slot.outputLength == 0)
      {
        auto it = std::ranges::find_if(iocsObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == iocsObjects.end())
        {
          continue;
        }
        it->frameOffset = dapModuleOffset;
        dapModuleOffset++;
      }
      if (slot.inputLength > 0)
      {
        auto it = std::ranges::find_if(iocsObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == iocsObjects.end())
        {
          continue;
        }
        if (frameOffset != 0)
        {
          frameOffset--;
        }
        it->frameOffset = frameOffset;
      }
      if (slot.outputLength > 0)
      {
        auto it = std::ranges::find_if(ioDataObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == ioDataObjects.end())
        {
          continue;
        }
        if (frameOffset != 0)
        {
          frameOffset--;
        }
        it->frameOffset = frameOffset;
      }
    }
    *
    std::uint16_t ioModuleOffset = 0;
 
    for (const IOSlot& slot : setup.slots)
    {
      if ((slot.inputLength >= 0 && slot.outputLength == 0) || (slot.inputLength > 0 && slot.outputLength > 0))
      {
        auto it = std::ranges::find_if(iocsObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == ioDataObjects.end())
        {
          continue;
        }
        it->frameOffset = ioModuleOffset;
        ioModuleOffset++;
      }
      else if (slot.outputLength > 0)
      {
        auto it = std::ranges::find_if(ioDataObjects,
                                       [&slot](const IOCRAPIObject& s)
        {
          return slot.slot == s.slotNumber && slot.subslot == s.subslotNumber;
        });
        if (it == ioDataObjects.end())
        {
          continue;
        }
        it->frameOffset = ioModuleOffset;
        ioModuleOffset++;
      }
    }
*
}
*/
  // ---------------------------------------------------------------------------
  // Validate object counts before converting to the wire uint16_t fields.
  // ---------------------------------------------------------------------------
  if (ioDataObjects.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: too many IODataObjects");
  }
 
  if (iocsObjects.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: too many IOCSObjects");
  }
 
  Bytes apiBlock;
 
  // API = 0
  wire::PutU32(apiBlock, 0);
 
  wire::PutU16(apiBlock, static_cast<std::uint16_t>(ioDataObjects.size()));
 
  for (const IOCRAPIObject& object : ioDataObjects)
  {
    const Bytes bytes = object.ToBytes();
    apiBlock.insert(apiBlock.end(), bytes.begin(), bytes.end());
  }
 
  wire::PutU16(apiBlock, static_cast<std::uint16_t>(iocsObjects.size()));
 
  for (const IOCRAPIObject& object : iocsObjects)
  {
    const Bytes bytes = object.ToBytes();
    apiBlock.insert(apiBlock.end(), bytes.begin(), bytes.end());
  }
 
  // ---------------------------------------------------------------------------
  // Build IOCR block header.
  // ---------------------------------------------------------------------------
 
  PNBlockHeader blockHeader;
 
  blockHeader.blockType = PNIOCRBlockReqHeader::BLOCK_TYPE; // 0x0102
 
  // The IOCR fixed header is followed by the API block.
  //
  // blockLength excludes:
  //   - BlockType      2 bytes
  //   - BlockLength    2 bytes
  //
  const std::size_t totalSize = PNIOCRBlockReqHeader::kSize + apiBlock.size();
 
  if (totalSize < 4 || totalSize - 4 > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("BuildIocrBlock: IOCR block is too large");
  }
 
  blockHeader.blockLength = static_cast<std::uint16_t>(totalSize - 4);
 
  blockHeader.blockVersionHigh = VERSION_HIGH;
  blockHeader.blockVersionLow = VERSION_LOW;
 
  PNIOCRBlockReqHeader iocrHeader;
 
  const Bytes blockHeaderBytes = blockHeader.ToBytes();
 
  std::ranges::copy(blockHeaderBytes, iocrHeader.blockHeader.begin());
 
  iocrHeader.iocrType = static_cast<std::uint16_t>(iocrType);
  iocrHeader.iocrReference = static_cast<std::uint16_t>(iocrType);
  iocrHeader.etherTypeLT = PROFINET_ETHERTYPE; // 0x8892
  iocrHeader.iocrProperties = setup.applicationRelations.startupMode == StartupMode::Advanced
                                  ? 0x00000002
                                  : 0x00000001; // RT_CLASS_1, RT_CLASS_3 maybe later
  // iocrHeader.iocrProperties = 0x00000002; /// class2?
  iocrHeader.dataLength = static_cast<std::uint16_t>(std::max<std::uint16_t>(40, dataLength));
 
  /*
  if (setup.applicationRelations.startupMode == StartupMode::Advanced)
  {
    //   Input  CR -> 0x8000
    //   Output CR -> 0x8001
 
    iocrHeader.frameId = static_cast<std::uint16_t>(0x8000 + static_cast<std::uint16_t>(iocrType) - 1);
  }
  else
  {
    //   Input  CR -> 0xC000
    //   Output CR -> 0xC001
 
    iocrHeader.frameId = static_cast<std::uint16_t>(0xC000 + static_cast<std::uint16_t>(iocrType) - 1);
  }
*/
  iocrHeader.frameId = setup.applicationRelations.startupMode == StartupMode::Advanced
                           ? iocrType == IocrType::Input
                                 ? 0x9000
                                 : 0xFFFF
                       : iocrType == IocrType::Input
                           ? 0xC000
                           : 0xC001;
 
  // iocrHeader.frameId = iocrType == IocrType::Input ? 0xC000 : 0xC001;
 
  iocrHeader.sendClockFactor = setup.sendClockFactor;
  iocrHeader.reductionRatio = setup.reductionRatio;
 
  // These are currently controller/protocol configuration values rather
  // than GSDML-derived slot properties.
  iocrHeader.phase = 8;
  iocrHeader.sequence = 0;
  iocrHeader.frameSendOffset = 0xFFFFFFFF;
  iocrHeader.watchdogFactor = setup.watchdogFactor;
  iocrHeader.dataHoldFactor = setup.dataHoldFactor;
  iocrHeader.iocrTagHeader = 0xC000;
  iocrHeader.iocrMulticastMac = {};
 
  // One API: API 0.
  iocrHeader.numberOfApis = 1;
 
  // ---------------------------------------------------------------------------
  // Serialize complete block.
  // ---------------------------------------------------------------------------
 
  Bytes out = iocrHeader.ToBytes();
 
  out.insert(out.end(), apiBlock.begin(), apiBlock.end());
 
  return out;
}
 
Bytes RPCCon::BuildExpectedSubmoduleBlock(const IOCRSetup& setup)
{
  Bytes expectedSlotModuleBlocks;
  blocks::ExpectedSubmoduleBlockReq builder;
  std::uint16_t previousSlotnr = 0;
  for (const auto& slot : setup.slots)
  {
    if (previousSlotnr != slot.slot)
    {
      previousSlotnr = slot.slot;
      const auto slotBytes = builder.ToBytes();
      expectedSlotModuleBlocks.insert(expectedSlotModuleBlocks.end(), slotBytes.begin(), slotBytes.end());
      builder.Clear();
    }
    const bool hasInput = slot.inputLength > 0;
    const bool hasOutput = slot.outputLength > 0;
 
    const blocks::ModuleType submoduleType =
        [&]()
    {
      if (hasInput && hasOutput)
      {
        return blocks::ModuleType::InputAndOutput;
      }
 
      if (hasInput)
      {
        return blocks::ModuleType::InputOnly;
      }
 
      if (hasOutput)
      {
        return blocks::ModuleType::OutputOnly;
      }
 
      return blocks::ModuleType::None;
    }();
 
    builder.AddSubmodule(
        0,
        slot.slot,
        slot.subslot,
        slot.moduleIdent,
        slot.submoduleIdent,
        static_cast<std::uint16_t>(submoduleType),
        slot.inputLength,
        slot.outputLength);
  }
  const auto slotBytes = builder.ToBytes();
  expectedSlotModuleBlocks.insert(expectedSlotModuleBlocks.end(), slotBytes.begin(), slotBytes.end());
  return expectedSlotModuleBlocks;
}
 
std::uint16_t RPCCon::ParseIocrResponse(const Bytes& responseData, int iocrType)
{
  std::size_t offset = 0;
  while (offset + blockHeaderLength <= responseData.size())
  {
    auto hdr = PeekBlockHeader(responseData, offset);
    if (hdr.blockType == PNIOCRBlockRes::BLOCK_TYPE)
    {
      const Bytes blockBytes(responseData.begin() + offset, responseData.end());
      try
      {
        auto res = PNIOCRBlockRes::Parse(blockBytes);
        if (res.iocrType == iocrType)
        {
          return res.frameId;
        }
      }
      // NOLINTNEXTLINE(bugprone-empty-catch)
      catch (const std::exception&)
      {
        // fall through and keep scanning
      }
    }
    offset += 4 + hdr.blockLength;
  }
  return 0;
}
 
PNRPCHeader RPCCon::SendReceive(const PNRPCHeader& request)
{
  Bytes rpcBytes = request.ToBytes();
  auto timeoutInMilliSeconds = std::chrono::floor<std::chrono::milliseconds>(std::chrono::duration<double>(timeout));
  PNRPCHeader resp;
  while (true)
  {
    CheckTimeout();
    const Bytes responseBytes = rpcTransport->SendReceive(rpcBytes, timeoutInMilliSeconds);
 
    if (responseBytes.size() < PNRPCHeader::kFixedSize)
    {
      throw RPCError("Failed to parse RPC response: data too short (" + std::to_string(responseBytes.size()) + " bytes)");
    }
    try
    {
      resp = PNRPCHeader::Parse(responseBytes);
    }
    catch (const std::exception& e)
    {
      throw RPCError(std::string("Failed to parse RPC response: ") + e.what());
    }
 
    if (resp.packetType == PNRPCHeader::REQUEST)
    {
      continue;
    }
    break;
  }
  if (resp.packetType == PNRPCHeader::FAULT)
  {
    throw RPCFaultError("RPC fault from " + info.name, resp.operationNumber);
  }
  if (resp.packetType == PNRPCHeader::REJECT)
  {
    throw RPCError("RPC request rejected by " + info.name);
  }
  if (resp.packetType != PNRPCHeader::RESPONSE)
  {
    // Extract the complete formatted error message into a dedicated const variable
    const std::string errorMessage = std::format("Unexpected RPC packet type: 0x{:02X}", resp.packetType);
 
    throw RPCError(errorMessage);
  }
 
  live = true;
  liveMonotonic = std::chrono::steady_clock::now();
  return resp;
}
 
void RPCCon::CheckTimeout()
{
  if (live && !reconnecting)
  {
    auto elapsed = std::chrono::duration<double>(std::chrono::steady_clock::now() - liveMonotonic).count();
    if (elapsed >= CONNECTION_TIMEOUT)
    {
      reconnecting = true;
      Connect();
    }
  }
}
 
std::optional<ConnectResult> RPCCon::Connect(std::optional<MacAddress> mac,
                                             bool withAlarmCr,
                                             std::optional<IOCRSetup> setup)
{
  if (!live)
  {
    if (!mac)
    {
      throw std::invalid_argument("srcMac required for initial connection");
    }
    this->srcMac = mac;
  }
  else
  {
    arUuid = RandomUuidBytes();
    activityUuid = RandomUuidBytes();
    sessionKey = RandomNonzeroU16();
    if (mac)
    {
      this->srcMac = mac;
    }
  }
  if (!this->srcMac)
  {
    throw std::invalid_argument("No source MAC address available");
  }
 
  // NOLINTNEXTLINE(performance-unnecessary-value-param)
  this->iocrSetup = std::move(setup);
 
  const std::uint32_t arProperties = this->iocrSetup
                                         ? this->iocrSetup->applicationRelations.startupMode == StartupMode::Advanced
                                               ? 0x40000011U
                                               : 0x00000011U
                                         : 0x00000111U;
  std::string initiatorStationName = "rhodium-profinet-connector";
 
  PNBlockHeader block;
  block.blockType = BlockType::ApplicationRelationRequest; // ARBlockReq, 0x0101
  block.blockLength = static_cast<std::uint16_t>(PNARBlockRequest::kFixedSize - 2 + initiatorStationName.length() - 2);
  block.blockVersionHigh = VERSION_HIGH;
  block.blockVersionLow = VERSION_LOW;
 
  const std::uint16_t arType = this->iocrSetup ? 0x0001 : 0x0006;
 
  PNARBlockRequest ar;
  std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), ar.blockHeader.begin());
  ar.arType = arType;
  ar.arUuid = arUuid;
  ar.sessionKey = sessionKey;
  ar.cmInitiatorMacAddress = *mac;
  ar.cmInitiatorObjectUuid = localObjectUuid;
  ar.arProperties = arProperties; // this->iocrSetup ? 0x00000011U : 0x00000111U; // arProperties;
  ar.cmInitiatorActivityTimeoutFactor = 600;
  ar.initiatorUdpRtport = PROFINET_ETHERTYPE;
  ar.stationNameLength = static_cast<std::uint16_t>(initiatorStationName.length());
  const Bytes initiatorStationNameInBytes(initiatorStationName.begin(), initiatorStationName.end());
  ar.cmInitiatorStationName = initiatorStationNameInBytes;
 
  Bytes nrdPayload = ar.ToBytes();
 
  if (this->iocrSetup)
  {
    Bytes inputIocr = BuildIocrBlock(IocrType::Input, *this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), inputIocr.begin(), inputIocr.end());
 
    Bytes outputIocr = BuildIocrBlock(IocrType::Output, *this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), outputIocr.begin(), outputIocr.end());
 
    Bytes expectedSubmodule = BuildExpectedSubmoduleBlock(*this->iocrSetup);
    nrdPayload.insert(nrdPayload.end(), expectedSubmodule.begin(), expectedSubmodule.end());
 
    Bytes alarmCrData = BuildAlarmCrBlock();
    nrdPayload.insert(nrdPayload.end(), alarmCrData.begin(), alarmCrData.end());
    withAlarmCr = true;
  }
  else if (withAlarmCr)
  {
    Bytes alarmCrData = BuildAlarmCrBlock();
    nrdPayload.insert(nrdPayload.end(), alarmCrData.begin(), alarmCrData.end());
  }
 
  const PNNRDData nrd = CreateNrd(nrdPayload);
  const PNRPCHeader req = CreateRpc(PNRPCHeader::CONNECT, nrd.ToBytes());
 
  try
  {
    const PNRPCHeader resp = SendReceive(req);
    const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
 
    if (nrdResp.argsMaximumStatus != 0)
    {
      const PNIOError pnioErr = PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
      throw RPCConnectionError(std::string("Connect rejected by device: ") + pnioErr.what());
    }
 
    reconnecting = false;
 
    std::optional<ConnectResult> result;
    if (this->iocrSetup)
    {
      result = ConnectResult{};
      result->arUuid = arUuid;
      result->sessionKey = sessionKey;
      inputFrameId = ParseIocrResponse(nrdResp.payload, 1);
      result->inputFrameId = inputFrameId;
      outputFrameId = ParseIocrResponse(nrdResp.payload, 2);
      result->outputFrameId = outputFrameId;
      result->header = raw::ParseRawRpcHeader(nrdResp.ToBytes());
      if (result.has_value())
      {
        dataRepresentation = result->header->drep;
        /*
        remoteObjectUuid = result->header->objectUuid;
        interfaceUuid = result->header->interfaceUuid;
        activityUuid = result->header->activityUuid;
*/
      }
    }
 
    if (withAlarmCr)
    {
      deviceAlarmRef = ParseAlarmCrResponse(nrdResp.payload);
      if (deviceAlarmRef >= 0)
      {
        alarmCrEnabled = true;
        if (result)
        {
          result->deviceAlarmRef = deviceAlarmRef;
        }
      }
    }
 
    return result;
  }
  catch (const RPCError& e)
  {
    throw RPCConnectionError(std::string("Failed to connect: ") + e.what());
  }
}
 
PNIODHeader RPCCon::Read(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx)
{
  CheckTimeout();
 
  PNBlockHeader block;
  block.blockType = PNBlockHeader::IODReadRequestHeader;
  block.blockLength = PNBlockHeader::DEFAULT_BLOCK_LENGTH;
  block.blockVersionHigh = VERSION_HIGH;
  block.blockVersionLow = VERSION_LOW;
 
  PNIODHeader iod;
  std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), iod.blockHeader.begin());
  iod.sequenceNumber = 0;
  iod.arUuid = arUuid;
  iod.api = api;
  iod.slot = slot;
  iod.subslot = subslot;
  iod.padding1 = 0;
  iod.index = idx;
  iod.length = 4096;
  iod.targetArUuid = {};
  iod.padding2 = {};
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::READ, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
 
  return PNIODHeader::Parse(nrdResp.payload);
}
 
PNIODHeader RPCCon::ReadImplicit(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx)
{
  PNBlockHeader block;
  block.blockType = PNBlockHeader::IODReadRequestHeader;
  block.blockLength = 60;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODHeader iod;
  std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), iod.blockHeader.begin());
  iod.sequenceNumber = 0;
  iod.arUuid = {}; // empty AR UUID for implicit read
  iod.api = api;
  iod.slot = slot;
  iod.subslot = subslot;
  iod.padding1 = 0;
  iod.index = idx;
  iod.length = 4096;
  iod.targetArUuid = {};
  iod.padding2 = {};
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::IMPLICIT_READ, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
 
  return PNIODHeader::Parse(nrdResp.payload);
}
 
void RPCCon::Write(std::uint32_t api, std::uint16_t slot, std::uint16_t subslot, std::uint16_t idx,
                   const Bytes& data)
{
  CheckTimeout();
 
  PNBlockHeader block;
  block.blockType = BlockType::IoDataWriteRequest; // 0x0008; // IODWriteReqHeader
  block.blockLength = 60;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODHeader iod;
  std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), iod.blockHeader.begin());
  iod.sequenceNumber = 0;
  iod.arUuid = arUuid;
  iod.api = api;
  iod.slot = slot;
  iod.subslot = subslot;
  iod.padding1 = 0;
  iod.index = idx;
  iod.length = static_cast<std::uint32_t>(data.size());
  iod.targetArUuid = {};
  iod.padding2 = {};
  iod.payload = data;
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::WRITE, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
}
 
Bytes RPCCon::ReadRaw(std::uint16_t idx, std::uint16_t slot, std::uint16_t subslot)
{
  return Read(0, slot, subslot, idx).payload;
}
 
PNInM0 RPCCon::ReadIm0(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM0::Parse(Read(0, slot, subslot, PNInM0::IDX).payload);
}
PNInM1 RPCCon::ReadIm1(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM1::Parse(Read(0, slot, subslot, PNInM1::IDX).payload);
}
PNInM2 RPCCon::ReadIm2(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM2::Parse(Read(0, slot, subslot, PNInM2::IDX).payload);
}
PNInM3 RPCCon::ReadIm3(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM3::Parse(Read(0, slot, subslot, PNInM3::IDX).payload);
}
PNInM4 RPCCon::ReadIm4(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM4::Parse(Read(0, slot, subslot, PNInM4::IDX).payload);
}
PNInM5 RPCCon::ReadIm5(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM5::Parse(Read(0, slot, subslot, PNInM5::IDX).payload);
}
PNInM6 RPCCon::ReadIm6(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM6::Parse(Read(0, slot, subslot, PNInM6::IDX).payload);
}
PNInM7 RPCCon::ReadIm7(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM7::Parse(Read(0, slot, subslot, PNInM7::IDX).payload);
}
PNInM8 RPCCon::ReadIm8(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM8::Parse(Read(0, slot, subslot, PNInM8::IDX).payload);
}
PNInM9 RPCCon::ReadIm9(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM9::Parse(Read(0, slot, subslot, PNInM9::IDX).payload);
}
PNInM10 RPCCon::ReadIm10(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM10::Parse(Read(0, slot, subslot, PNInM10::IDX).payload);
}
PNInM11 RPCCon::ReadIm11(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM11::Parse(Read(0, slot, subslot, PNInM11::IDX).payload);
}
PNInM12 RPCCon::ReadIm12(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM12::Parse(Read(0, slot, subslot, PNInM12::IDX).payload);
}
PNInM13 RPCCon::ReadIm13(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM13::Parse(Read(0, slot, subslot, PNInM13::IDX).payload);
}
PNInM14 RPCCon::ReadIm14(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM14::Parse(Read(0, slot, subslot, PNInM14::IDX).payload);
}
PNInM15 RPCCon::ReadIm15(std::uint16_t slot, std::uint16_t subslot)
{
  return PNInM15::Parse(Read(0, slot, subslot, PNInM15::IDX).payload);
}
 
AllIM RPCCon::ReadAllIm(std::uint16_t slot, std::uint16_t subslot)
{
  AllIM result;
  result.im0 = ReadIm0(slot, subslot); // I&M0 is mandatory; propagate failure.
 
  auto tryRead = [&](auto& field, auto memberFn)
  {
    try
    {
      field = (this->*memberFn)(slot, subslot);
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const RPCError&)
    {
      // fall through and keep scanning
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const std::exception&)
    {
      // fall through and keep scanning
    }
  };
  tryRead(result.im1, &RPCCon::ReadIm1);
  tryRead(result.im2, &RPCCon::ReadIm2);
  tryRead(result.im3, &RPCCon::ReadIm3);
  tryRead(result.im4, &RPCCon::ReadIm4);
  tryRead(result.im5, &RPCCon::ReadIm5);
  tryRead(result.im6, &RPCCon::ReadIm6);
  tryRead(result.im7, &RPCCon::ReadIm7);
  tryRead(result.im8, &RPCCon::ReadIm8);
  tryRead(result.im9, &RPCCon::ReadIm9);
  tryRead(result.im10, &RPCCon::ReadIm10);
  tryRead(result.im11, &RPCCon::ReadIm11);
  tryRead(result.im12, &RPCCon::ReadIm12);
  tryRead(result.im13, &RPCCon::ReadIm13);
  tryRead(result.im14, &RPCCon::ReadIm14);
  tryRead(result.im15, &RPCCon::ReadIm15);
  return result;
}
 
// =============================================================================
// Configuration / diagnosis / topology
// =============================================================================
 
std::vector<blocks::WriteMultipleResult> RPCCon::WriteMultiple(const std::vector<WriteItem>& writes)
{
  CheckTimeout();
  if (writes.empty())
  {
    return {};
  }
 
  blocks::IODWriteMultipleBuilder builder(arUuid, /*SeqNum=*/0);
  for (const auto& w : writes)
  {
    builder.AddWrite(w.slot, w.subslot, w.index, w.data, w.api);
  }
  const Bytes payload = builder.Build();
 
  PNBlockHeader block;
  block.blockType = BlockType::IoDataWriteRequest; // 0x0008; // IODWriteReqHeader
  block.blockLength = 60;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODHeader iod;
  std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), iod.blockHeader.begin());
  iod.sequenceNumber = 0;
  iod.arUuid = arUuid;
  iod.api = 0xFFFFFFFF; // wildcard for multiple
  iod.slot = 0xFFFF;    // wildcard
  iod.subslot = 0xFFFF; // wildcard
  iod.padding1 = 0;
  iod.index = blocks::IODWriteMultipleBuilder::writeMultipleIndex; // 0xE040
  iod.length = static_cast<std::uint32_t>(payload.size());
  iod.targetArUuid = {};
  iod.padding2 = {};
  iod.payload = payload;
 
  const PNNRDData nrd = CreateNrd(iod.ToBytes());
  const PNRPCHeader req = CreateRpc(PNRPCHeader::WRITE, nrd.ToBytes());
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
 
  return blocks::ParseWriteMultipleResponse(nrdResp.payload);
}
 
blocks::ModuleDiffBlock RPCCon::ReadModuleDiff()
{
  const PNIODHeader iod = Read(0, 0, 0, MODULE_DIFF_BLOCK);
  return blocks::ParseModuleDiffBlock(iod.payload);
}
 
diagnosis::DiagnosisData RPCCon::ReadDiagnosis(std::uint16_t slot, std::uint16_t subslot, std::uint16_t index)
{
  try
  {
    const PNIODHeader iod = Read(0, slot, subslot, index);
    const Bytes& data = iod.payload;
 
    if (data.size() > 6)
    {
      diagnosis::DiagnosisData result = diagnosis::ParseDiagnosisBlock(data, 0, slot, subslot);
      if (result.entries.empty())
      {
        result = diagnosis::ParseDiagnosisSimple(data, 0, slot, subslot);
      }
      return result;
    }
    diagnosis::DiagnosisData empty;
    empty.api = 0;
    empty.slot = slot;
    empty.subslot = subslot;
    empty.rawData = data;
    return empty;
  }
  catch (const RPCError&)
  {
    diagnosis::DiagnosisData empty;
    empty.api = 0;
    empty.slot = slot;
    empty.subslot = subslot;
    return empty;
  }
}
 
std::map<std::uint16_t, diagnosis::DiagnosisData> RPCCon::ReadAllDiagnosis()
{
  static const std::vector<std::tuple<std::uint16_t, std::uint16_t, std::uint16_t>> kDiagnosisProbes = {
      {0x800A, 0, 0}, // Channel diagnosis for slot 0
      {0x800B, 0, 0}, // All diagnosis for slot 0
      {0x800C, 0, 1}, // Channel diagnosis for subslot 1
      {0xF000, 0, 0}, // All diagnosis data (device level)
      {0xF00A, 0, 0}, // Channel diagnosis (API level)
      {0xF00B, 0, 0}, // All diagnosis (API level)
  };
 
  std::map<std::uint16_t, diagnosis::DiagnosisData> results;
  for (const auto& [idx, Slot, Subslot] : kDiagnosisProbes)
  {
    try
    {
      const diagnosis::DiagnosisData diag = ReadDiagnosis(Slot, Subslot, idx);
      if (!diag.entries.empty())
      {
        results[idx] = diag;
      }
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const RPCError&)
    {
    }
  }
  return results;
}
 
blocks::PDRealData RPCCon::ReadPdRealData()
{
  const PNIODHeader iod = Read(0, 0, 1, PD_REAL_DATA);
  return blocks::ParsePdRealData(iod.payload);
}
 
blocks::RealIdentificationData RPCCon::ReadRealIdentificationData()
{
  const PNIODHeader iod = Read(0, 0, 1, REAL_ID_API);
  return blocks::ParseRealIdentificationData(iod.payload);
}
 
std::vector<blocks::SlotInfo> RPCCon::DiscoverSlots()
{
  return ReadRealIdentificationData().slots;
}
 
std::pair<blocks::PDRealData, blocks::RealIdentificationData> RPCCon::DiscoverTopology()
{
  return {ReadPdRealData(), ReadRealIdentificationData()};
}
 
std::map<std::uint16_t, rpc::IndexProbeResult> RPCCon::EnumerateIndices(
    std::uint16_t slot, std::uint16_t subslot, std::optional<std::vector<std::uint16_t>> customIndices)
{
  std::vector<std::pair<std::uint16_t, std::string>> probeList;
 
  if (customIndices)
  {
    for (auto idx : *customIndices)
    {
      probeList.emplace_back(idx, GetIndexName(idx));
    }
  }
  else
  {
    auto extend = [&](const IndexNamePairs& src)
    {
      probeList.insert(probeList.end(), src.begin(), src.end());
    };
    extend(ImIndices());
    extend(DiagnosisIndices("subslot"));
    extend(DiagnosisIndices("device"));
    extend(PortIndices());
    extend(InterfaceIndices());
    extend(DeviceIndices());
    probeList.emplace_back(EXPECTED_ID_SUBSLOT, "ExpectedIdentificationData");
    probeList.emplace_back(REAL_ID_SUBSLOT, "RealIdentificationData");
    probeList.emplace_back(MODULE_DIFF_BLOCK, "ModuleDiffBlock");
    probeList.emplace_back(RECORD_INPUT_DATA, "RecordInputData");
    probeList.emplace_back(RECORD_OUTPUT_DATA, "RecordOutputData");
  }
 
  std::map<std::uint16_t, IndexProbeResult> results;
  std::vector<std::uint16_t> seen;
  for (const auto& [idx, Name] : probeList)
  {
    if (std::ranges::find(seen, idx) != seen.end())
    {
      continue;
    }
    seen.push_back(idx);
 
    IndexProbeResult r;
    r.name = Name;
    try
    {
      const PNIODHeader iod = Read(0, slot, subslot, idx);
      if (!iod.payload.empty())
      {
        r.status = "readable";
        r.size = iod.payload.size();
      }
      else
      {
        r.status = "empty";
      }
    }
    catch (const PNIOError& e)
    {
      r.status = "error";
      r.error = e.what();
      r.errorCode1 = e.errorCode1;
      r.errorCode2 = e.errorCode2;
    }
    catch (const RPCError& e)
    {
      r.status = "error";
      r.error = e.what();
    }
    results[idx] = r;
  }
 
  return results;
}
 
Bytes RPCCon::SendControl(BlockType blockType, ControlCommand controlCommand,
                          bool waitResponse, const Bytes& subBlocks)
{
  if (!live)
  {
    throw RPCError("Not connected");
  }
 
  PNBlockHeader block;
  block.blockType = blockType;
  block.blockLength = 28;
  block.blockVersionHigh = 0x01;
  block.blockVersionLow = 0x00;
 
  PNIODReleaseBlock controlBlock;
 
  std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), controlBlock.blockHeader.begin());
  controlBlock.padding1 = 0;
  controlBlock.arUuid = arUuid;
  controlBlock.sessionKey = sessionKey;
  controlBlock.padding2 = 0;
  controlBlock.controlCommand = controlCommand;
  controlBlock.controlBlockProperties = 0;
 
  Bytes nrdPayload = controlBlock.ToBytes();
  nrdPayload.insert(nrdPayload.end(), subBlocks.begin(), subBlocks.end());
 
  const PNNRDData nrd = CreateNrd(nrdPayload);
  const PNRPCHeader req = CreateRpc(PNRPCHeader::CONTROL, nrd.ToBytes());
 
  if (!waitResponse)
  {
    Bytes rpcBytes = req.ToBytes();
    rpcTransport->Send(rpcBytes);
    return {};
  }
 
  const PNRPCHeader resp = SendReceive(req);
  const PNNRDData nrdResp = PNNRDData::Parse(resp.payload);
  if (nrdResp.argsMaximumStatus != 0)
  {
    throw PNIOError::FromArgsStatus(nrdResp.argsMaximumStatus);
  }
  return nrdResp.payload;
}
 
Bytes RPCCon::PrmBegin()
{
  return SendControl(BlockType::ParameterizationBeginRequest, ControlCommand::PrmBegin);
}
Bytes RPCCon::PrmEnd()
{
  return SendControl(BlockType::ControlPrmEndRequest, ControlCommand::PrmEnd);
}
Bytes RPCCon::ReadyForRtClass3()
{
  return SendControl(BlockType::ControlRtClass3Request, ControlCommand::ReadyForRtClass3);
}
 
namespace raw
{
std::optional<RawRpcHeader> ParseRawRpcHeader(const Bytes& data)
{
  if (data.size() < PNRPCHeader::kFixedSize)
  {
    return std::nullopt;
  }
  wire::Reader r(data);
  RawRpcHeader h;
  h.version = r.U8();    // 0x04
  h.packetType = r.U8(); // 0x00 = Request, 0x02 = Response
  h.flags1 = r.U8();
  h.flags2 = r.U8();
 
  // drep is 3 bytes (indices 4, 5, 6), drep[0] = 0x10 = Little-Endian, drep[0] = 0x00 = Big-Endian
  h.drep = r.Fixed<3U>();
 
  h.serialHigh = r.U8();
 
  h.objectUuid = r.Fixed<uuidLenght>();
  h.interfaceUuid = r.Fixed<uuidLenght>();
  h.activityUuid = r.Fixed<uuidLenght>();
 
  h.isLittleEndian = (h.drep[0] & RawRpcHeader::kLittleEndianDrepFlag) != 0U;
 
  // Field offsets per DCE/RPC v4 specification:
  // Bytes 56-59: server_boot_time
  r.SkipTo(60U);
  h.interfaceVersion = h.isLittleEndian ? r.U32LittleEndian() : r.U32();
  h.sequenceNumber = h.isLittleEndian ? r.U32LittleEndian() : r.U32();
  h.operationNumber = h.isLittleEndian ? r.U16LittleEndian() : r.U16();
  // Bytes 70-71: interface_hint
  // Bytes 72-73: activity_hint
  // Bytes 74-75: len (args_len)
  // Bytes 76-77: fragnum
  // Byte  78:    auth_proto
  r.SkipTo(79U);
  h.serialLow = r.U8();
 
  h.payload = Bytes(data.begin() + PNRPCHeader::kFixedSize, data.end());
 
  return h;
}
 
} // namespace raw
 
Bytes RPCCon::ApplicationReady(double timeoutSec)
{
  if (!live)
  {
    throw RPCError("Not connected");
  }
 
  auto timeoutInMilliSeconds = std::chrono::floor<std::chrono::milliseconds>(std::chrono::duration<double>(timeoutSec));
  Bytes result;
  while (true)
  {
    CheckTimeout();
    Bytes respBytes;
    // This maybe wrong... i am too tired to validate
    // Receive incoming UDP request (and capture sender endpoint if transport supports it)
 
    asio::ip::udp::endpoint senderEndpoint;
    Bytes buf = ccontrolTransport->Receive(timeoutInMilliSeconds, senderEndpoint);
    auto hdr = raw::ParseRawRpcHeader(buf);
    if (!hdr)
    {
      continue;
    }
    if (hdr->packetType != PNRPCHeader::REQUEST)
    {
      continue;
    }
    if (hdr->operationNumber != PNRPCHeader::CONTROL)
    {
      continue;
    }
 
    const Bytes& nrdPayload = hdr->payload;
    if (nrdPayload.size() < 20)
    {
      continue;
    }
 
    wire::Reader r1(nrdPayload);
    const std::uint32_t nrdArgsMaximum = hdr->isLittleEndian ? r1.U32LittleEndian()
                                                             : r1.U32();
    // r.SkipTo(16);
    // const std::uint32_t nrdActual = le ? r.U32LittleEndian()
    //                                    : r.U32();
    // (void)nrdActual; // do I need  nrdActual?
 
    Bytes nrdBody(nrdPayload.begin() + 20, nrdPayload.end());
    if (nrdBody.size() < 32)
    {
      continue;
    }
    wire::Reader r(nrdBody);
    // BlockType is ALWAYS Big-Endian (0x0112 = IODControlReq / ApplicationReady)
    const std::uint16_t blockType = r.U16();
 
    // ControlCommand is located at offset 28 inside PNIODControlBlockReq
    // (Block Header: 6 bytes + ARUUID: 16 bytes + SessionKey: 2 bytes + Reserved: 4 bytes = 28 bytes)
    r.SkipTo(PNIODHeader::kContolCommandOffset);
    const std::uint16_t controlCmd = r.U16();
 
    std::cout << "Parsed BlockType: 0x" << std::hex << blockType
              << ", ControlCmd: 0x" << controlCmd << std::dec << "\n";
 
    if (blockType != BLOCK_IOD_CONTROL_APP_READY_REQ) // 0x0112
    {
      std::cerr << "Ignoring non-AppReady block: 0x" << std::hex << blockType << "\n";
      continue;
    }
 
    // (control_cmd expected to be CONTROL_CMD_APP_READY; devices that
    // deviate are still accepted)
    //(void)controlCmd;
 
    // Build CControl response: block 0x8112, cmd=DONE.
    PNBlockHeader respBlock;
    respBlock.blockType = BlockType::ControlApplicationReadyResponse;
 
    // version(2) +  padding1(2) + arUuid(16) + sessionKey(2) + padding2(2) + controlcmd (2) + blockproperties(2)
    // = 2 + 2 + 16 + 2 + 2 + 2 + 2 = 28 or 0x001C
    constexpr std::uint16_t kApplicationReadyBlockLength = 28;
 
    respBlock.blockLength = kApplicationReadyBlockLength;
 
    respBlock.blockVersionHigh = 0x01;
    respBlock.blockVersionLow = 0x00;
 
    PNIODReleaseBlock respControl;
    std::ranges::copy(respBlock.ToBytes() | std::views::take(blockHeaderLength), respControl.blockHeader.begin());
    respControl.padding1 = 0;
    respControl.arUuid = arUuid;
    respControl.sessionKey = sessionKey;
    respControl.padding2 = 0;
    respControl.controlCommand = ControlCommand::Done;
    respControl.controlBlockProperties = 0;
 
    Bytes respNrdPayload = respControl.ToBytes();
    const auto respNrdLen = static_cast<std::uint32_t>(respNrdPayload.size());
 
    Bytes respNrd;
    if (hdr->isLittleEndian)
    {
      wire::PutLittleEndian<std::uint32_t>(respNrd, 0); // pnio status = OK
      wire::PutLittleEndian(respNrd, respNrdLen);       // args length
      wire::PutLittleEndian(respNrd, nrdArgsMaximum);   // maximum count
      wire::PutLittleEndian<std::uint32_t>(respNrd, 0); // offset
      wire::PutLittleEndian(respNrd, respNrdLen);       // actual count
    }
    else
    {
      wire::PutU32(respNrd, 0);
      wire::PutU32(respNrd, respNrdLen);
      wire::PutU32(respNrd, nrdArgsMaximum);
      wire::PutU32(respNrd, 0);
      wire::PutU32(respNrd, respNrdLen);
    }
    wire::PutFixed(respNrd, respNrdPayload);
 
 
    respBytes.push_back(hdr->version);          // 0x00 : Protocol Version (`0x04`)
    respBytes.push_back(PNRPCHeader::RESPONSE); // 0x01 : Packet Type (0x02` = Resp)
    constexpr auto flag1 = static_cast<std::uint8_t>(raw::Flags1::NoFack | raw::Flags1::LastFragment);
    constexpr std::uint8_t flag2 = 0x00; // all special reserved flags, leave empty
    respBytes.push_back(flag1);          // 0x02 : First flags group
    respBytes.push_back(flag2);          // 0x03 : Second flags group
                                         // respBytes.push_back(0x00); // flags1
                                         // respBytes.push_back(0x00); // flags2
 
    // respBytes.push_back(0x00); // data representation / [0] defines Endianness
    // respBytes.push_back(0x00); // data representation - drep[1]
    // respBytes.push_back(0x00); // data representation - drep[2]
    // respBytes.push_back(0x00); // serial high
 
    wire::PutFixed(respBytes, hdr->drep); // 0x04 - 0x06 Data Representation (`drep[0]` defines Endianness)
    respBytes.push_back(hdr->serialHigh);
    wire::PutFixed(respBytes, hdr->objectUuid);
    wire::PutFixed(respBytes, hdr->interfaceUuid);
    wire::PutFixed(respBytes, hdr->activityUuid);
    // respBytes.insert(respBytes.end(), localObjectUuid.begin(), localObjectUuid.end());
    // respBytes.insert(respBytes.end(), interfaceUuid.begin(), interfaceUuid.end());
    // respBytes.insert(respBytes.end(), activityUuid.begin(), activityUuid.end());
 
    if (hdr->isLittleEndian)
    {
      wire::PutLittleEndian<std::uint32_t>(respBytes, 0); // server_boot_time
      wire::PutLittleEndian(respBytes, hdr->interfaceVersion);
      wire::PutLittleEndian(respBytes, hdr->sequenceNumber);
      wire::PutLittleEndian(respBytes, hdr->operationNumber);
      wire::PutLittleEndian(respBytes, PNRPCHeader::defaultInterfaceHint); // interface_hint
      wire::PutLittleEndian(respBytes, PNRPCHeader::defaultActivityHint);  // activity_hint
      wire::PutLittleEndian(respBytes, static_cast<std::uint16_t>(respNrd.size()));
      wire::PutLittleEndian<std::uint16_t>(respBytes, 0); // fragment_number
    }
    else
    {
      wire::PutU32(respBytes, 0); // server_boot_time
      wire::PutU32(respBytes, hdr->interfaceVersion);
      wire::PutU32(respBytes, hdr->sequenceNumber);
      wire::PutU16(respBytes, hdr->operationNumber);
      wire::PutU16(respBytes, PNRPCHeader::defaultInterfaceHint); // interface_hint
      wire::PutU16(respBytes, PNRPCHeader::defaultActivityHint);  // activity_hint
      wire::PutU16(respBytes, static_cast<std::uint16_t>(respNrd.size()));
      wire::PutU16(respBytes, 0); // fragment_number
    }
 
    respBytes.push_back(0);
    respBytes.push_back(hdr->serialLow);
 
    wire::PutFixed(respBytes, respNrd);
 
    ccontrolTransport->SendTo(respBytes, senderEndpoint);
 
    live = true;
    liveMonotonic = std::chrono::steady_clock::now();
    result = nrdBody;
    break;
  }
  return result;
}
 
void RPCCon::Disconnect()
{
  if (!live)
  {
    return;
  }
 
  try
  {
    PNBlockHeader block;
    block.blockType = BlockType::ReleaseRequest;
    block.blockLength = 28;
    block.blockVersionHigh = 0x01;
    block.blockVersionLow = 0x00;
 
    PNIODReleaseBlock release;
    std::ranges::copy(block.ToBytes() | std::views::take(blockHeaderLength), release.blockHeader.begin());
    release.padding1 = 0;
    release.arUuid = arUuid;
    release.sessionKey = sessionKey;
    release.padding2 = 0;
    release.controlCommand = ControlCommand::Release;
    release.controlBlockProperties = 0;
 
    const PNNRDData nrd = CreateNrd(release.ToBytes());
    const PNRPCHeader req = CreateRpc(PNRPCHeader::RELEASE, nrd.ToBytes());
    Bytes rpcBytes = req.ToBytes();
    rpcTransport->Send(rpcBytes);
  }
  // NOLINTNEXTLINE(bugprone-empty-catch)
  catch (...)
  {
    // best-effort
  }
 
  live = false;
}
 
void RPCCon::Close() noexcept
{
  Disconnect();
  rpcTransport->Close();
  ccontrolTransport->Close();
}
 
} // namespace profinet::rpc