blocks.cpp

Go to the documentation of this file.

 
 
#include "profinet/blocks.h"
 
#include <algorithm>
#include <cstring>
#include <map>
#include <ranges>
#include <stdexcept>
 
#include "profinet/indices.h"
#include "profinet/wire.h"
 
namespace profinet::blocks
{
 
namespace
{
std::string Latin1Decode(const std::uint8_t* data, std::size_t len)
{
  std::string out;
  out.reserve(len);
  for (std::size_t i = 0; i < len; ++i)
  {
    const std::uint8_t b = data[i];
    if (b < 0x80)
    {
      out.push_back(static_cast<char>(b));
    }
    else
    {
      out.push_back(static_cast<char>(0xC0 | (b >> 6)));
      out.push_back(static_cast<char>(0x80 | (b & 0x3F)));
    }
  }
  return out;
}
 
const std::map<std::uint16_t, std::string>& MauTypeNames()
{
  static const std::map<std::uint16_t, std::string> table = {
      {0, "Unknown"},
      {10, "10BASE-T HD"},
      {11, "10BASE-T FD"},
      {15, "100BASE-TX HD"},
      {16, "100BASE-TX FD"},
      {17, "100BASE-FX HD"},
      {18, "100BASE-FX FD"},
      {29, "1000BASE-T HD"},
      {30, "1000BASE-T FD"},
      {21, "1000BASE-X HD"},
      {22, "1000BASE-X FD"},
      {40, "10GBASE-T"},
  };
  return table;
}
 
} // namespace
 
std::string BlockHeader::TypeName() const
{
  return GetBlockTypeName(blockType);
}
 
std::string SlotInfo::ToString() const
{
  // Formats directly and prints subslot as a 4-digit, zero-padded hex value
  return std::format("SlotInfo(api={}, slot={}, subslot=0x{:04X})", api, slot, subslot);
}
 
std::string PortInfo::MauTypeName() const
{
  auto it = MauTypeNames().find(mauType);
  if (it != MauTypeNames().end())
  {
    return it->second;
  }
  return "Unknown(" + std::to_string(mauType) + ")";
}
 
std::string PortInfo::LinkState() const
{
  switch (linkStateLink)
  {
    case 0:
      return "Unknown";
    case 1:
      return "Up";
    case 2:
      return "Down";
    case 3:
      return "Testing";
    default:
      return "Unknown(" + std::to_string(linkStateLink) + ")";
  }
}
 
std::pair<BlockHeader, std::size_t> ParseBlockHeader(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + blockHeaderLength)
  {
    throw std::invalid_argument("Block header requires 6 bytes, got " +
                                std::to_string(data.size() >= offset ? data.size() - offset : 0));
  }
  wire::Reader r(data.data() + offset, blockHeaderLength);
  BlockHeader h;
  h.blockType = static_cast<BlockType>(r.U16());
  h.blockLength = r.U16();
  h.versionHigh = r.U8();
  h.versionLow = r.U8();
  return {h, offset + blockHeaderLength};
}
 
std::tuple<std::uint32_t, std::uint16_t, std::uint16_t, std::size_t> ParseMultipleBlockHeader(const Bytes& data,
                                                                                              std::size_t offset)
{
  if (data.size() < offset + 10)
  {
    throw std::invalid_argument("MultipleBlockHeader body requires 8 bytes after padding");
  }
  wire::Reader r(data.data() + offset, 10);
  r.Skip(2); // padding
  const std::uint32_t api = r.U32();
  const std::uint16_t slot = r.U16();
  const std::uint16_t subslot = r.U16();
  return {api, slot, subslot, offset + 10};
}
 
InterfaceInfo ParsePdInterfaceDataReal(const Bytes& data, std::size_t offset, std::size_t blockHeaderSize)
{
  std::size_t start = offset;
 
  auto alignFromBlock = [&](std::size_t bodyOffset) -> std::size_t
  {
    const std::size_t blockOffset = blockHeaderSize + (bodyOffset - start);
    const std::size_t alignedBlock = Align4(blockOffset);
    return start + (alignedBlock - blockHeaderSize);
  };
 
  if (data.size() <= offset)
  {
    throw std::invalid_argument("Truncated interface data (missing chassis length)");
  }
  const std::uint8_t chassisLen = data[offset];
  offset += sizeof(std::uint8_t);
 
  if (data.size() < offset + chassisLen)
  {
    throw std::invalid_argument("Truncated chassis ID");
  }
  const std::string chassisId = Latin1Decode(&data[offset], chassisLen);
  offset += chassisLen;
 
  offset = alignFromBlock(offset);
 
  if (data.size() < offset + macAddressLength)
  {
    throw std::invalid_argument("Truncated MAC address");
  }
  InterfaceInfo info;
  info.chassisId = chassisId;
  std::ranges::copy(data | std::views::drop(offset) | std::views::take(macAddressLength), info.macAddress.begin());
  offset += macAddressLength;
 
  offset = alignFromBlock(offset);
 
  if (data.size() < offset + 12)
  {
    throw std::invalid_argument("Truncated IP configuration");
  }
  std::ranges::copy(data | std::views::drop(offset) | std::views::take(4), info.ipAddress.begin());
  offset += 4;
 
  std::ranges::copy(data | std::views::drop(offset) | std::views::take(4), info.subnetMask.begin());
  offset += 4;
 
  std::ranges::copy(data | std::views::drop(offset) | std::views::take(4), info.gateway.begin());
  offset += 4;
 
  return info;
}
 
PortInfo ParsePdPortDataReal(const Bytes& data, std::size_t offset, std::uint16_t slot, std::uint16_t subslot)
{
  const std::size_t start = offset;
  offset = Align4(offset);
  wire::Reader r(data);
  r.SkipTo(offset);
 
  if (data.size() >= offset + (2 * sizeof(std::uint16_t)))
  {
    slot = r.U16();
    subslot = r.U16();
    offset += 2 * sizeof(std::uint16_t);
  }
 
  if (data.size() < offset + 1)
  {
    return PortInfo{.slot = slot, .subslot = subslot, .portId = "", .mauType = 0, .linkStatePort = 0, .linkStateLink = 0, .mediaType = 0, .peers = {}, .domainBoundary = 0, .multicastBoundary = 0};
  }
 
  const std::uint8_t portIdLen = data[offset];
  offset += sizeof(std::uint8_t);
 
  std::string portId;
  if (data.size() >= offset + portIdLen)
  {
    portId = Latin1Decode(&data[offset], portIdLen);
    offset += portIdLen;
  }
 
  std::uint8_t numPeers = 0;
  std::vector<PeerInfo> peers;
  if (data.size() > offset)
  {
    numPeers = data[offset];
    offset += sizeof(std::uint8_t);
  }
 
  offset = start + Align4(offset - start);
 
  for (std::uint8_t i = 0; i < numPeers; ++i)
  {
    if (data.size() < offset + 1)
    {
      break;
    }
 
    const std::uint8_t peerPortLen = data[offset];
    offset += sizeof(std::uint8_t);
    std::string peerPortId;
    if (data.size() >= offset + peerPortLen)
    {
      peerPortId = Latin1Decode(&data[offset], peerPortLen);
      offset += peerPortLen;
    }
 
    if (data.size() < offset + 1)
    {
      break;
    }
    const std::uint8_t peerChassisLen = data[offset];
    offset += sizeof(std::uint8_t);
    std::string peerChassisId;
    if (data.size() >= offset + peerChassisLen)
    {
      peerChassisId = Latin1Decode(&data[offset], peerChassisLen);
      offset += peerChassisLen;
    }
 
    offset = start + Align4(offset - start);
 
    std::array<std::uint8_t, macAddressLength> peerMac{};
    if (data.size() >= offset + macAddressLength)
    {
      std::ranges::copy(data.begin() + offset, data.begin() + offset + macAddressLength, peerMac.begin());
      offset += macAddressLength;
    }
 
    offset = start + Align4(offset - start);
 
    peers.push_back({.portId = peerPortId, .chassisId = peerChassisId, .macAddress = peerMac});
  }
 
  std::uint16_t mauType = 0;
  if (data.size() >= offset + 2)
  {
    r.SkipTo(offset);
    mauType = r.U16();
    offset += sizeof(std::uint16_t);
  }
 
  offset = start + Align4(offset - start);
 
  std::uint32_t domainBoundary = 0;
  std::uint32_t multicastBoundary = 0;
  if (data.size() >= offset + (2 * sizeof(std::uint32_t)))
  {
    r.SkipTo(offset);
 
    domainBoundary = r.U32();
    offset += sizeof(std::uint32_t);
 
    multicastBoundary = r.U32();
    offset += sizeof(std::uint32_t);
  }
 
  std::uint8_t linkStatePort = 0;
  std::uint8_t linkStateLink = 0;
  if (data.size() >= offset + (2 * sizeof(std::uint8_t)))
  {
    linkStatePort = data[offset];
    offset += sizeof(std::uint8_t);
 
    linkStateLink = data[offset];
    offset += sizeof(std::uint8_t);
  }
 
  offset = start + Align4(offset - start);
 
  std::uint32_t mediaType = 0;
  if (data.size() >= offset + sizeof(std::uint32_t))
  {
    r.SkipTo(offset);
 
    mediaType = r.U32();
  }
 
  return PortInfo{.slot = slot, .subslot = subslot, .portId = portId, .mauType = mauType, .linkStatePort = linkStatePort, .linkStateLink = linkStateLink, .mediaType = mediaType, .peers = peers, .domainBoundary = domainBoundary, .multicastBoundary = multicastBoundary};
}
 
PDRealData ParsePdRealData(const Bytes& data)
{
  PDRealData result;
  std::size_t offset = 0;
 
  while (data.size() >= offset + blockHeaderLength)
  {
    BlockHeader header;
    std::size_t newOffset = 0;
    try
    {
      std::tie(header, newOffset) = ParseBlockHeader(data, offset);
    }
    catch (const std::invalid_argument&)
    {
      break;
    }
 
    std::size_t blockEnd = newOffset + header.BodyLength();
    if (blockEnd > data.size())
    {
      blockEnd = data.size();
    }
 
    if (header.blockType == BlockType::MultipleHeader)
    {
      try
      {
        auto [api, slotNr, subslotNr, nestedOffset] = ParseMultipleBlockHeader(data, newOffset);
 
        SlotInfo slotInfo;
        slotInfo.api = api;
        slotInfo.slot = slotNr;
        slotInfo.subslot = subslotNr;
 
        while (nestedOffset + blockHeaderLength <= blockEnd)
        {
          BlockHeader nestedHeader;
          std::size_t nestedBody = 0;
          try
          {
            std::tie(nestedHeader, nestedBody) = ParseBlockHeader(data, nestedOffset);
          }
          catch (const std::invalid_argument&)
          {
            break;
          }
 
          std::size_t nestedEnd = nestedBody + nestedHeader.BodyLength();
          if (nestedEnd > blockEnd)
          {
            nestedEnd = blockEnd;
          }
          slotInfo.blocks.push_back(nestedHeader.TypeName());
 
          if (nestedHeader.blockType == BlockType::PortDataInterfaceDataReal)
          {
            try
            {
              result.interface = ParsePdInterfaceDataReal(data, nestedBody);
            }
            catch (const std::invalid_argument&)
            {
            }
          }
          else if (nestedHeader.blockType == BlockType::PortDataReal)
          {
            try
            {
              result.ports.push_back(ParsePdPortDataReal(data, nestedBody, slotNr, subslotNr));
            }
            catch (const std::invalid_argument&)
            {
            }
          }
 
          nestedOffset = nestedEnd;
        }
 
        result.slots.push_back(slotInfo);
        result.rawBlocks.emplace_back(api, slotNr, subslotNr,
                                      Bytes(data.begin() + newOffset, data.begin() + blockEnd));
      }
      catch (const std::invalid_argument&)
      {
      }
    }
 
    offset = blockEnd;
  }
 
  return result;
}
 
RealIdentificationData ParseRealIdentificationData(const Bytes& data)
{
  RealIdentificationData result;
  std::size_t offset = 0;
 
  if (data.size() >= blockHeaderLength)
  {
    try
    {
      BlockHeader header;
      std::tie(header, offset) = ParseBlockHeader(data, 0);
      // Only accept it as a real block header if the type actually matches
      // a RealIdentificationData block — otherwise the data is raw body
      // content (no header), as callers parsing RPC read responses that
      // have already stripped the outer NRD envelope may provide.
      if (header.blockType == BlockType::RealIdentificationData ||
          header.blockType == BlockType::RealIdentificationDataApi)
      {
        result.version = {header.versionHigh, header.versionLow};
      }
      else
      {
        offset = 0;
        result.version = {1, 0};
      }
    }
    catch (const std::invalid_argument&)
    {
      offset = 0;
      result.version = {1, 0};
    }
  }
 
  if (data.size() < offset + 2)
  {
    return result;
  }
 
  wire::Reader rOuter(data.data() + offset, data.size() - offset);
 
  const bool v11 = result.version.first >= 1 && result.version.second >= 1;
 
  if (v11)
  {
    const std::uint16_t numApis = rOuter.U16();
    for (std::uint16_t i = 0; i < numApis; ++i)
    {
      if (rOuter.Remaining() < sizeof(std::uint32_t) + sizeof(std::uint16_t))
      {
        break;
      }
      const std::uint32_t api = rOuter.U32();
      const std::uint16_t numSlots = rOuter.U16();
 
      for (std::uint16_t s = 0; s < numSlots; ++s)
      {
        if (rOuter.Remaining() < sizeof(std::uint16_t) + sizeof(std::uint32_t) + sizeof(std::uint16_t))
        {
          break;
        }
        const std::uint16_t slotNr = rOuter.U16();
        const std::uint32_t moduleIdent = rOuter.U32();
        const std::uint16_t numSubslots = rOuter.U16();
 
        for (std::uint16_t ss = 0; ss < numSubslots; ++ss)
        {
          if (rOuter.Remaining() < sizeof(std::uint16_t) + sizeof(std::uint32_t))
          {
            break;
          }
          const std::uint16_t subslotNr = rOuter.U16();
          const std::uint32_t submoduleIdent = rOuter.U32();
          // result.Slots.push_back({slot_nr, subslot_nr, Api, ModuleIdent, SubmoduleIdent, {}});
          result.slots.push_back({.slot = slotNr, .subslot = subslotNr, .api = api, .moduleIdent = moduleIdent, .submoduleIdent = submoduleIdent, .blocks = {}});
        }
      }
    }
  }
  else
  {
    const std::uint16_t numSlots = rOuter.U16();
    for (std::uint16_t s = 0; s < numSlots; ++s)
    {
      if (rOuter.Remaining() < sizeof(std::uint16_t) + sizeof(std::uint32_t) + sizeof(std::uint16_t))
      {
        break;
      }
      const std::uint16_t slotNr = rOuter.U16();
      const std::uint32_t moduleIdent = rOuter.U32();
      const std::uint16_t numSubslots = rOuter.U16();
 
      for (std::uint16_t ss = 0; ss < numSubslots; ++ss)
      {
        if (rOuter.Remaining() < sizeof(std::uint16_t) + sizeof(std::uint32_t))
        {
          break;
        }
        const std::uint16_t subslotNr = rOuter.U16();
        const std::uint32_t submoduleIdent = rOuter.U32();
        result.slots.push_back({.slot = slotNr, .subslot = subslotNr, .api = 0, .moduleIdent = moduleIdent, .submoduleIdent = submoduleIdent, .blocks = {}});
      }
    }
  }
 
  return result;
}
 
std::optional<PortStatistics> ParsePortStatistics(const Bytes& data, std::size_t offset)
{
  if (data.size() < offset + 26)
  {
    return std::nullopt;
  }
  wire::Reader r(data.data() + offset, 26);
  PortStatistics s;
  s.counterStatus = r.U16();
  s.inOctets = r.U32();
  s.outOctets = r.U32();
  s.inDiscards = r.U32();
  s.outDiscards = r.U32();
  s.inErrors = r.U32();
  s.outErrors = r.U32();
  return s;
}
 
// =============================================================================
// ModuleDiffBlock
// =============================================================================
 
std::string ModuleDiffSubmodule::StateName() const
{
  return GetSubmoduleStateName(submoduleState);
}
 
bool ModuleDiffSubmodule::IsOk() const
{
  return submoduleState == SUBMODULE_STATE_OK;
}
 
std::string ModuleDiffModule::StateName() const
{
  return GetModuleStateName(moduleState);
}
bool ModuleDiffModule::IsProper() const
{
  return moduleState == MODULE_STATE_PROPER_MODULE;
}
 
bool ModuleDiffBlock::AllOk() const
{
  for (const auto& mod : modules)
  {
    if (!mod.IsProper())
    {
      return false;
    }
    for (const auto& sub : mod.submodules)
    {
      if (!sub.IsOk())
      {
        return false;
      }
    }
  }
  return true;
}
 
std::vector<std::tuple<std::uint16_t, std::uint16_t, std::string>> ModuleDiffBlock::GetMismatches() const
{
  std::vector<std::tuple<std::uint16_t, std::uint16_t, std::string>> mismatches;
  for (const auto& mod : modules)
  {
    if (!mod.IsProper())
    {
      mismatches.emplace_back(mod.slotNumber, 0, mod.StateName());
    }
    for (const auto& sub : mod.submodules)
    {
      if (!sub.IsOk())
      {
        mismatches.emplace_back(mod.slotNumber, sub.subslotNumber, sub.StateName());
      }
    }
  }
  return mismatches;
}
 
ModuleDiffBlock ParseModuleDiffBlock(const Bytes& data)
{
  if (data.size() < blockHeaderLength)
  {
    return ModuleDiffBlock{};
  }
 
  wire::Reader r(data);
  const auto blockType = static_cast<BlockType>(r.U16());
  r.Skip(4); // block_len, ver_hi, ver_lo
 
  if (blockType != BlockType::ModuleDifference)
  {
    // Extract the formatted error message into a dedicated const variable
    const std::string message = std::format("Expected block type {} (0x8104), got {} (0x{:04X})",
                                            GetBlockTypeName(BlockType::ModuleDifference),
                                            GetBlockTypeName(blockType),
                                            static_cast<std::uint16_t>(blockType));
 
    throw std::invalid_argument(message);
  }
 
  if (r.Remaining() < 2)
  {
    return ModuleDiffBlock{};
  }
  const std::uint16_t numApis = r.U16();
 
  std::vector<ModuleDiffModule> modules;
 
  for (std::uint16_t i = 0; i < numApis; ++i)
  {
    if (r.Remaining() < sizeof(std::uint32_t) + sizeof(std::uint16_t))
    {
      break;
    }
    const std::uint32_t api = r.U32();
    const std::uint16_t numModules = r.U16();
 
    for (std::uint16_t m = 0; m < numModules; ++m)
    {
      if (r.Remaining() < sizeof(std::uint16_t) + sizeof(std::uint32_t) + (2 * sizeof(std::uint16_t)))
      {
        break;
      }
      const std::uint16_t slotNr = r.U16();
      const std::uint32_t moduleIdent = r.U32();
      const std::uint16_t moduleState = r.U16();
      const std::uint16_t numSubmodules = r.U16();
 
      std::vector<ModuleDiffSubmodule> submodules;
      for (std::uint16_t s = 0; s < numSubmodules; ++s)
      {
        if (r.Remaining() < sizeof(std::uint16_t) + sizeof(std::uint32_t) + sizeof(std::uint16_t))
        {
          break;
        }
        const std::uint16_t subslotNr = r.U16();
        const std::uint32_t submoduleIdent = r.U32();
        const std::uint16_t submoduleState = r.U16();
        submodules.push_back({.subslotNumber = subslotNr, .submoduleIdentNumber = submoduleIdent, .submoduleState = submoduleState});
      }
 
      modules.push_back({.api = api, .slotNumber = slotNr, .moduleIdentNumber = moduleIdent, .moduleState = moduleState, .submodules = submodules});
    }
  }
 
  return ModuleDiffBlock{modules};
}
 
// =============================================================================
// IODWriteMultiple
// =============================================================================
 
IODWriteMultipleBuilder& IODWriteMultipleBuilder::AddWrite(std::uint16_t slot, std::uint16_t subslot,
                                                           std::uint16_t index, Bytes data, std::uint32_t api)
{
  writes.push_back({.api = api, .slot = slot, .subslot = subslot, .index = index, .data = std::move(data)});
  return *this;
}
 
Bytes IODWriteMultipleBuilder::BuildWriteBlock(std::uint16_t seq, std::uint32_t api, std::uint16_t slot,
                                               std::uint16_t subslot, std::uint16_t index,
                                               const Bytes& data) const
{
  Bytes out;
  wire::PutU16(out, writeMultipleBlockType);
  wire::PutU16(out, 60);
  wire::PutU8(out, 0x01);
  wire::PutU8(out, 0x00);
  wire::PutU16(out, seq);
  wire::PutFixed(out, arUuid);
  wire::PutU32(out, api);
  wire::PutU16(out, slot);
  wire::PutU16(out, subslot);
  wire::PutU16(out, 0);
  wire::PutU16(out, index);
  wire::PutU32(out, static_cast<std::uint32_t>(data.size()));
  Bytes padding(24, 0);
  out.insert(out.end(), padding.begin(), padding.end());
  out.insert(out.end(), data.begin(), data.end());
  return out;
}
 
Bytes IODWriteMultipleBuilder::BuildHeader(std::size_t blocksLen) const
{
  Bytes out;
  wire::PutU16(out, writeMultipleBlockType);
  wire::PutU16(out, 60);
  wire::PutU8(out, 0x01);
  wire::PutU8(out, 0x00);
  wire::PutU16(out, seqNum);
  wire::PutFixed(out, arUuid);
  wire::PutU32(out, 0xFFFFFFFF);
  wire::PutU16(out, 0xFFFF);
  wire::PutU16(out, 0xFFFF);
  wire::PutU16(out, 0);
  wire::PutU16(out, writeMultipleIndex);
  wire::PutU32(out, static_cast<std::uint32_t>(blocksLen));
  Bytes padding(24, 0);
  out.insert(out.end(), padding.begin(), padding.end());
  return out;
}
 
Bytes IODWriteMultipleBuilder::Build() const
{
  Bytes blocksData;
 
  for (std::size_t i = 0; i < writes.size(); ++i)
  {
    const auto& w = writes[i];
    Bytes block = BuildWriteBlock(static_cast<std::uint16_t>(i), w.api, w.slot, w.subslot, w.index, w.data);
    blocksData.insert(blocksData.end(), block.begin(), block.end());
 
    if (i + 1 < writes.size())
    {
      std::size_t padLen = (4 - (block.size() % 4)) % 4;
      blocksData.insert(blocksData.end(), padLen);
    }
  }
 
  const Bytes header = BuildHeader(blocksData.size());
  Bytes out = header;
  out.insert(out.end(), blocksData.begin(), blocksData.end());
  return out;
}
 
std::vector<WriteMultipleResult> ParseWriteMultipleResponse(const Bytes& data)
{
  std::vector<WriteMultipleResult> results;
  if (data.size() < 64)
  {
    return results;
  }
  wire::Reader r(data);
  constexpr std::uint16_t recordLenOffset = 36;
  r.SkipTo(recordLenOffset);
 
  const std::uint32_t recordLen = r.U32();
 
  std::size_t offset = 64;
  const std::size_t end = std::min<std::size_t>(offset + recordLen, data.size());
 
  while (offset + 56 <= end)
  {
    wire::Reader r(data.data() + offset, 56);
    const std::uint16_t blockType = r.U16();
    const std::uint16_t blockLen = r.U16();
    r.Skip(2); // ver_hi, ver_lo
    const std::uint16_t seqNum = r.U16();
    r.Skip(uuidLenght); // ar_uuid
    const std::uint32_t api = r.U32();
    const std::uint16_t slot = r.U16();
    const std::uint16_t subslot = r.U16();
    r.Skip(2); // padding
    const std::uint16_t index = r.U16();
    r.Skip(4); // record_data_length
    const std::uint16_t addVal1 = r.U16();
    const std::uint16_t addVal2 = r.U16();
    const std::uint32_t status = r.U32();
 
    if (blockType != PNIODWriteRes::BLOCK_TYPE)
    {
      break;
    }
 
    results.push_back({.seqNum = seqNum, .api = api, .slot = slot, .subslot = subslot, .index = index, .status = status, .additionalValue1 = addVal1, .additionalValue2 = addVal2});
 
    const std::size_t blockSize = 4 + blockLen;
    const std::size_t pad = (4 - (blockSize % 4)) % 4;
    offset += blockSize + pad;
  }
 
  return results;
}
 
// =============================================================================
// ExpectedSubmodule Structures
// =============================================================================
 
Bytes ExpectedSubmoduleDataDescription::ToBytes() const
{
  Bytes out;
  wire::PutU16(out, dataDescription);
  wire::PutU16(out, submoduleDataLength);
  wire::PutU8(out, lengthIocs);
  wire::PutU8(out, lengthIops);
  return out;
}
 
Bytes ExpectedSubmodule::ToBytes() const
{
  Bytes out;
  wire::PutU16(out, subslotNumber);
  wire::PutU32(out, submoduleIdentNumber);
  wire::PutU16(out, submoduleProperties);
  for (const auto& dd : dataDescriptions)
  {
    Bytes d = dd.ToBytes();
    out.insert(out.end(), d.begin(), d.end());
  }
  return out;
}
 
Bytes ExpectedSubmoduleSlot::ToBytes() const
{
  Bytes out;
  wire::PutU32(out, api);
  wire::PutU16(out, slotNumber);
  wire::PutU32(out, moduleIdentNumber);
  wire::PutU16(out, moduleProperties);
 
  if (submodules.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("ExpectedSubmoduleAPI: too many submodules");
  }
  wire::PutU16(out, static_cast<std::uint16_t>(submodules.size()));
 
  for (const auto& sm : submodules)
  {
    Bytes s = sm.ToBytes();
    out.insert(out.end(), s.begin(), s.end());
  }
  return out;
}
 
Bytes ExpectedSubmoduleAPI::ToBytes() const
{
  Bytes out;
 
  //  wire::PutU16(out, 0); // reserved
  //  wire::PutU16(out, static_cast<std::uint16_t>(slots.size()));
 
  if (slots.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("ExpectedSubmoduleAPI: too many modules");
  }
 
  // wire::PutU16(out, static_cast<std::uint16_t>(slots.size()));
 
  for (const auto& slot : slots)
  {
    Bytes s = slot.ToBytes();
    out.insert(out.end(), s.begin(), s.end());
  }
  return out;
}
 
ExpectedSubmoduleBlockReq& ExpectedSubmoduleBlockReq::AddSubmodule(std::uint32_t api, std::uint16_t slot,
                                                                   std::uint16_t subslot,
                                                                   std::uint32_t moduleIdent,
                                                                   std::uint32_t submoduleIdent,
                                                                   std::uint16_t submoduleType,
                                                                   std::uint16_t inputLength,
                                                                   std::uint16_t outputLength)
{
  ExpectedSubmoduleAPI* apiEntry = nullptr;
  for (auto& a : apis)
  {
    if (a.api == api)
    {
      apiEntry = &a;
      break;
    }
  }
  if (apiEntry == nullptr)
  {
    ExpectedSubmoduleAPI newApi;
    newApi.api = api;
    apis.push_back(newApi);
    apiEntry = &apis.back();
  }
 
  // Find Slot inside API
  auto it = std::ranges::find_if(apiEntry->slots, [slot](const auto& s)
  {
    return s.slotNumber == slot;
  });
 
  auto* slotEntry = (it != apiEntry->slots.end()) ? &(*it) : nullptr;
  if (slotEntry == nullptr)
  {
    apiEntry->slots.push_back(ExpectedSubmoduleSlot{
        .api = api,
        .slotNumber = slot,
        .moduleIdentNumber = moduleIdent,
        .moduleProperties = 0,
        .submodules = {}});
    slotEntry = &apiEntry->slots.back();
  }
 
  std::vector<ExpectedSubmoduleDataDescription> dds;
  switch (submoduleType)
  {
    case 0: // NO_IO
            // NO DataDescription is encoded for a NO_IO submodule.
      dds.push_back({.dataDescription = 1, .submoduleDataLength = 0, .lengthIocs = 1, .lengthIops = 1});
      // dds.push_back({0, 0, 0, 0});
      break;
    case 1: // INPUT
      dds.push_back({.dataDescription = 1, .submoduleDataLength = inputLength, .lengthIocs = 1, .lengthIops = 1});
      break;
    case 2: // OUTPUT
      dds.push_back({.dataDescription = 2, .submoduleDataLength = outputLength, .lengthIocs = 1, .lengthIops = 1});
      break;
    case 3: // INPUT_OUTPUT
      dds.push_back({.dataDescription = 1, .submoduleDataLength = inputLength, .lengthIocs = 1, .lengthIops = 1});
      dds.push_back({.dataDescription = 2, .submoduleDataLength = outputLength, .lengthIocs = 1, .lengthIops = 1});
      break;
    default:
      break;
  }
 
  ExpectedSubmodule sm;
  sm.subslotNumber = subslot;
  sm.submoduleIdentNumber = submoduleIdent;
  sm.submoduleProperties = submoduleType; // 0x0001; // Use 0x0001 instead of submoduleType
  sm.dataDescriptions = std::move(dds);
  slotEntry->submodules.push_back(std::move(sm));
 
  return *this;
}
 
void ExpectedSubmoduleBlockReq::Clear()
{
  apis.clear();
}
 
Bytes ExpectedSubmoduleBlockReq::ToBytes() const
{
  if (apis.size() > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("ExpectedSubmoduleBlockReq: too many APIs");
  }
  Bytes body;
  // wire::PutU16(body, 0); // reserved
  // wire::PutU16(body, static_cast<std::uint16_t>(apis.size()));
 
  for (const auto& api : apis)
  {
    wire::PutU16(body, static_cast<std::uint16_t>(api.slots.size()));
    Bytes a = api.ToBytes();
    body.insert(body.end(), a.begin(), a.end());
  }
 
  auto blockLen = static_cast<std::uint16_t>(body.size() + 2); // +2 == BlockVersion length
  if (blockLen > std::numeric_limits<std::uint16_t>::max())
  {
    throw std::invalid_argument("ExpectedSubmoduleBlockReq: block too large");
  }
 
  Bytes header;
  wire::PutU16(header, expectedSubmoduleBlockReqBlockType);
  wire::PutU16(header, blockLen);
  wire::PutU8(header, 0x01);
  wire::PutU8(header, 0x00);
 
  Bytes out = header;
  out.insert(out.end(), body.begin(), body.end());
  return out;
}
 
} // namespace profinet::blocks