protocol.h

Go to the documentation of this file.

 
 
#pragma once
#define MAGIC_ENUM_RANGE_MIN 0
#define MAGIC_ENUM_RANGE_MAX 255
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <magic_enum.hpp>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "profinet/indices.h"
#include "profinet/util.h"
#include "profinet/wire.h"
 
namespace profinet
{
 
using Bytes = std::vector<std::uint8_t>;
 
inline constexpr int blockHeaderLength = 6;
 
// =============================================================================
// DCP Constants
// =============================================================================
enum class DcpFrameId : std::uint16_t
{
  Unknown = 0x0000,
 
  IdentifyRequest = 0xFEFE,
 
  IdentifyResponse = 0xFEFF,
 
  GetSet = 0xFEFD,
 
  Hello = 0xFEFC,
};
 
enum class DcpServiceId : std::uint8_t
{
  Unknown = 0x00,
 
  Get = 0x03,
 
  Set = 0x04,
 
  Identify = 0x05,
 
  Hello = 0x06,
};
 
enum class DcpServiceType : std::uint8_t
{
  Request = 0x00,
 
  ResponseSuccess = 0x01,
 
  ResponseUnsupported = 0x05,
};
 
enum class DcpOption : std::uint8_t
{
  Unknown = 0x00,
 
  Ip = 0x01,
 
  Device = 0x02,
 
  Dhcp = 0x03,
 
  Reserved = 0x04,
 
  Control = 0x05,
 
  DeviceInitiative = 0x06,
 
  Nme = 0x07,
 
  All = 0xFF,
};
 
enum class DcpIpSuboption : std::uint8_t
{
  Unknown = 0x00,
 
  Mac = 0x01,
 
  IpParameter = 0x02,
 
  FullIpSuite = 0x03,
};
 
enum class DcpDeviceSuboption : std::uint8_t
{
  Unknown = 0x00,
 
  Type = 0x01,
 
  Name = 0x02,
 
  DeviceId = 0x03,
 
  Role = 0x04,
 
  Options = 0x05,
 
  Alias = 0x06,
 
  Instance = 0x07,
 
  OemId = 0x08,
 
  Rsi = 0x0A,
};
 
enum class DcpControlSuboption : std::uint8_t
{
  Unknown = 0x00,
 
  Start = 0x01,
 
  Stop = 0x02,
 
  Signal = 0x03,
 
  Response = 0x04,
 
  FactoryReset = 0x05,
 
  ResetToFactory = 0x06,
};
 
enum class DcpDhcpSuboption : std::uint8_t
{
  Unknown = 0x00,
 
  Hostname = 0x0C,
 
  VendorSpec = 0x2B,
 
  ServerId = 0x36,
 
  ParamReq = 0x37,
 
  ClassId = 0x3C,
 
  ClientId = 0x3D,
 
  Fqdn = 0x51,
 
  Uuid = 0x61,
 
  Control = 0xFF
};
 
enum class DcpDeviceInitiativeSuboption : std::uint8_t
{
  Initiative = 0x01,
};
 
enum class DcpDeviceRole : std::uint8_t
{
  IoDevice = 0x01,
 
  IoController = 0x02,
 
  IoMultidevice = 0x04,
 
  PnSupervisor = 0x08,
};
 
constexpr DcpDeviceRole operator|(DcpDeviceRole lhs, DcpDeviceRole rhs)
{
  return static_cast<DcpDeviceRole>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
}
 
constexpr DcpDeviceRole operator&(DcpDeviceRole lhs, DcpDeviceRole rhs)
{
  return static_cast<DcpDeviceRole>(static_cast<std::uint8_t>(lhs) & static_cast<std::uint8_t>(rhs));
}
 
enum class DcpResetMode : std::uint16_t
{
  Communication = 0x0002,
 
  Application = 0x0004,
 
  Engineering = 0x0008,
 
  AllData = 0x0010,
 
  Device = 0x0020,
 
  Factory = 0x0040,
};
 
constexpr DcpResetMode operator|(DcpResetMode lhs, DcpResetMode rhs)
{
  return static_cast<DcpResetMode>(static_cast<std::uint16_t>(lhs) | static_cast<std::uint16_t>(rhs));
}
 
constexpr DcpResetMode operator&(DcpResetMode lhs, DcpResetMode rhs)
{
  return static_cast<DcpResetMode>(static_cast<std::uint16_t>(lhs) & static_cast<std::uint16_t>(rhs));
}
 
enum class DcpDeviceInitiative : std::uint16_t
{
  NoHello = 0x0000,
 
  IssueHello = 0x0001,
};
 
enum class DcpBlockError : std::uint8_t
{
  Ok = 0x00,
 
  OptionUnsupported = 0x01,
 
  SuboptionUnsupported = 0x02,
 
  SuboptionNotSet = 0x03,
 
  Resource = 0x04,
 
  SetNotPossible = 0x05,
 
  InOperation = 0x06,
};
 
enum class DcpResponseCode : std::uint8_t
{
  NoError = 0x00,
 
  OptionNotSupported = 0x01,
 
  SuboptionNotSupported = 0x02,
 
  SuboptionNotSet = 0x03,
 
  ResourceError = 0x04,
 
  SetNotPossible = 0x05,
 
  InOperationSetNotPossible = 0x06,
};
 
enum class DcpResetQualifier : std::uint16_t
{
  Unknown = 0x0000,
 
  ApplicationData = 0x0002,
 
  ApplicationDataAlternate = 0x0003,
 
  CommunicationParameter = 0x0004,
 
  CommunicationParameterAlternate = 0x0005,
 
  EngineeringParameter = 0x0006,
 
  EngineeringParameterAlternate = 0x0007,
 
  AllStoredData = 0x0008,
 
  AllStoredDataAlternate = 0x0009,
 
  EngineeringParameterExtended = 0x000A,
 
  EngineeringParameterExtendedAlternate = 0x000B,
 
  ToFactory = 0x0010,
 
  ToFactoryAlternate = 0x0011,
 
  Restore = 0x0012,
 
  RestoreAlternate = 0x0013,
};
 
enum class DcpBlockQualifier : std::uint16_t
{
  Temporary = 0x0000,
 
  Permanent = 0x0001,
};
 
enum class DcpIpBlockInfo : std::uint16_t
{
  NotSet = 0x0000,
 
  Set = 0x0001,
 
  SetByDhcp = 0x0002,
 
  NotSetConflict = 0x0080,
 
  SetConflict = 0x0081,
 
  SetByDhcpConflict = 0x0082,
};
// =============================================================================
// DCP - Discovery and Configuration Protocol
// =============================================================================
 
struct DcpBlockKey
{
  DcpOption option;
 
  std::uint8_t suboption;
 
  // constexpr bool operator==(const DcpBlockKey&) const = default;
  constexpr auto operator<=>(const DcpBlockKey&) const = default;
};
 
struct EthernetHeader
{
  MacAddress dst{};
 
  MacAddress src{};
 
  std::uint16_t type = 0;
 
  Bytes payload;
 
  static EthernetHeader Parse(const Bytes& data)
  {
    const int expectedEthernetHeaderSize = 14;
    if (data.size() < expectedEthernetHeaderSize)
    {
      throw std::runtime_error("EthernetHeader: insufficient data");
    }
    wire::Reader r(data);
    EthernetHeader h;
    h.dst = r.Fixed<macAddressLength>();
    h.src = r.Fixed<macAddressLength>();
    h.type = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, dst);
    wire::PutFixed(out, src);
    wire::PutU16(out, type);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct EthernetVLANHeader
{
  MacAddress dst{};
 
  MacAddress src{};
 
  std::uint16_t tPid = 0;
 
  std::uint16_t tCI = 0;
 
  std::uint16_t type = 0;
 
  Bytes payload;
 
  static EthernetVLANHeader Parse(const Bytes& data)
  {
    const int expectedEthernetVLANHeaderSize = 18;
 
    if (data.size() < expectedEthernetVLANHeaderSize)
    {
      throw std::runtime_error("EthernetVLANHeader: insufficient data");
    }
    wire::Reader r(data);
    EthernetVLANHeader h;
    h.dst = r.Fixed<macAddressLength>();
    h.src = r.Fixed<macAddressLength>();
    h.tPid = r.U16();
    h.tCI = r.U16();
    h.type = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, dst);
    wire::PutFixed(out, src);
    wire::PutU16(out, tPid);
    wire::PutU16(out, tCI);
    wire::PutU16(out, type);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNDCPHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t ETHER_TYPE = 0x8892;
  // NOLINTEND(readability-identifier-naming)
 
  DcpFrameId frameId = DcpFrameId::Unknown;
 
  DcpServiceId serviceId = DcpServiceId::Unknown;
 
  DcpServiceType serviceType = DcpServiceType::Request;
 
  std::uint32_t xId = 0;
 
  std::uint16_t respDelay = 0;
 
  std::uint16_t length = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 12;
 
  static PNDCPHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNDCPHeader: insufficient data");
    }
    wire::Reader r(data);
    PNDCPHeader h;
    h.frameId = static_cast<DcpFrameId>(r.U16());
    h.serviceId = static_cast<DcpServiceId>(r.U8());
    h.serviceType = static_cast<DcpServiceType>(r.U8());
    h.xId = r.U32();
    h.respDelay = r.U16();
    h.length = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, static_cast<std::uint16_t>(frameId));
    wire::PutU8(out, static_cast<std::uint8_t>(serviceId));
    wire::PutU8(out, static_cast<std::uint8_t>(serviceType));
    wire::PutU32(out, xId);
    wire::PutU16(out, respDelay);
    wire::PutU16(out, length);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct IPConfiguration
{
  std::string address;
 
  std::string netmask;
 
  std::string gateway;
};
 
struct PNDCPBlockRequest
{
  DcpOption option = DcpOption::Unknown;
 
  // DcpControlSuboption suboption = DcpControlSuboption::Unknown;
  std::uint8_t suboption = 0;
 
  std::uint16_t length = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 4;
 
  static PNDCPBlockRequest Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNDCPBlockRequest: insufficient data");
    }
    wire::Reader r(data);
    PNDCPBlockRequest b;
    b.option = static_cast<DcpOption>(r.U8());
    b.suboption = r.U8();
    b.length = r.U16();
    std::size_t avail = r.Remaining();
    b.payload = r.ReadBytes(std::min<std::size_t>(b.length, avail));
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU8(out, static_cast<std::uint8_t>(option));
    wire::PutU8(out, suboption);
    wire::PutU16(out, length);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
 
  [[nodiscard]] IPConfiguration ParseIp() const
  {
    const int defaultIPConfigurationBlockLength = 12; // 3 (ip,mask,gw) x4 = 12
    if (payload.size() < defaultIPConfigurationBlockLength)
    {
      throw std::runtime_error("PNDCPBlockRequest: short IP payload");
    }
    const int ipAddressIndex = 0;
    const int netmaskIndex = 4;
    const int gatewayIndex = 8;
    return {
        .address = String2Ip(std::span(payload).subspan<ipAddressIndex, 4>()),
        .netmask = String2Ip(std::span(payload).subspan<netmaskIndex, 4>()),
        .gateway = String2Ip(std::span(payload).subspan<gatewayIndex, 4>())};
  }
};
 
struct PNDCPBlock
{
  std::uint8_t option = 0;
 
  std::uint8_t suboption = 0;
 
  std::uint16_t length = 0;
 
  std::uint16_t status = 0;
 
  Bytes payload;
 
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::pair<std::uint8_t, std::uint8_t> IP_MAC{1, 1};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> IP_ADDRESS{1, 2};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> IP_FULL_SUITE{1, 3};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_TYPE{2, 1};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> NAME_OF_STATION{2, 2};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_ID{2, 3};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_ROLE{2, 4};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_OPTIONS{2, 5};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_ALIAS{2, 6};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_INSTANCE{2, 7};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> DEVICE_OEM_ID{2, 8};
 
  static constexpr std::pair<std::uint8_t, std::uint8_t> ALL{0xFF, 0xFF};
  // NOLINTEND(readability-identifier-naming)
 
  static constexpr std::size_t kFixedSize = 6;
 
  static PNDCPBlock Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNDCPBlock: insufficient data");
    }
    wire::Reader r(data);
    PNDCPBlock b;
    b.option = r.U8();
    b.suboption = r.U8();
    b.length = r.U16();
    b.status = r.U16();
    // payload_size_field="length", payload_offset=-2: payload length is
    // `length - 2` (the 2 bytes already consumed by `status`).
    std::size_t plSize = b.length >= 2 ? static_cast<std::size_t>(b.length - 2) : 0;
    std::size_t avail = r.Remaining();
    b.payload = r.ReadBytes(std::min(plSize, avail));
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU8(out, option);
    wire::PutU8(out, suboption);
    wire::PutU16(out, length);
    wire::PutU16(out, status);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
 
  [[nodiscard]] IPConfiguration ParseIp() const
  {
    const int defaultIPConfigurationBlockLength = 12; // 3 (ip,mask,gw) x4 = 12
    if (payload.size() < defaultIPConfigurationBlockLength)
    {
      throw std::runtime_error("PNDCPBlock: short IP payload");
    }
    const int ipAddressIndex = 0;
    const int netmaskIndex = 4;
    const int gatewayIndex = 8;
    return {
        .address = String2Ip(std::span(payload).subspan<ipAddressIndex, 4>()),
        .netmask = String2Ip(std::span(payload).subspan<netmaskIndex, 4>()),
        .gateway = String2Ip(std::span(payload).subspan<gatewayIndex, 4>())};
  }
};
 
// =============================================================================
// DCE/RPC - Remote Procedure Call
// =============================================================================
 
inline constexpr std::array<std::uint8_t, 12> kPnUuidSuffix = {
    0x6C, 0x97, 0x11, 0xD1, 0x82, 0x71, 0x00, 0xA0, 0x24, 0x42, 0xDF, 0x7D};
 
struct PNRPCHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint8_t REQUEST = 0x00;
 
  static constexpr std::uint8_t PING = 0x01;
 
  static constexpr std::uint8_t RESPONSE = 0x02;
 
  static constexpr std::uint8_t FAULT = 0x03;
 
  static constexpr std::uint8_t WORKING = 0x04;
 
  static constexpr std::uint8_t PONG = 0x05;
 
  static constexpr std::uint8_t REJECT = 0x06;
 
  static constexpr std::uint8_t ACK = 0x07;
 
  static constexpr std::uint8_t CANCEL = 0x08;
 
  static constexpr std::uint8_t FRAG_ACK = 0x09;
 
  static constexpr std::uint8_t CANCEL_ACK = 0x0A;
 
  static constexpr std::uint16_t CONNECT = 0x00;
 
  static constexpr std::uint16_t RELEASE = 0x01;
 
  static constexpr std::uint16_t READ = 0x02;
 
  static constexpr std::uint16_t WRITE = 0x03;
 
  static constexpr std::uint16_t CONTROL = 0x04;
 
  static constexpr std::uint16_t IMPLICIT_READ = 0x05;
 
  // NOLINTEND(readability-identifier-naming)
 
  static constexpr std::uint16_t defaultInterfaceHint = 0xFFFF;
  static constexpr std::uint16_t defaultActivityHint = 0xFFFF;
 
  std::uint8_t version = 4;
 
  std::uint8_t packetType = 0;
 
  std::uint8_t flags1 = 0;
 
  std::uint8_t flags2 = 0;
 
  std::array<std::uint8_t, 3> dataRepresentation{};
 
  std::uint8_t serialNrHigh = 0;
 
  std::array<std::uint8_t, uuidLenght> objectUuid{};
 
  std::array<std::uint8_t, uuidLenght> interfaceUuid{};
 
  std::array<std::uint8_t, uuidLenght> activityUuid{};
 
  std::uint32_t serverBootTime = 0;
 
  std::uint32_t interfaceVersion = 1;
 
  std::uint32_t sequenceNumber = 0;
 
  std::uint16_t operationNumber = 0;
 
  std::uint16_t interfaceHint = 0xFFFF;
 
  std::uint16_t activityHint = 0xFFFF;
 
  std::uint16_t lengthOfBody = 0;
 
  std::uint16_t fragmentNumber = 0;
 
  std::uint8_t authenticationProtocol = 0;
 
  std::uint8_t serialNrLow = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 80;
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidDevice()
  {
    return PrefixedUuid(0x00, 0x01);
  }
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidController()
  {
    return PrefixedUuid(0x00, 0x02);
  }
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidSupervisor()
  {
    return PrefixedUuid(0x00, 0x03);
  }
 
  static std::array<std::uint8_t, uuidLenght> IfaceUuidParamserver()
  {
    return PrefixedUuid(0x00, 0x04);
  }
 
  static PNRPCHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNRPCHeader: insufficient data");
    }
    wire::Reader r(data);
    PNRPCHeader h;
    h.version = r.U8();
    h.packetType = r.U8();
    h.flags1 = r.U8();
    h.flags2 = r.U8();
    h.dataRepresentation = r.Fixed<3>();
    h.serialNrHigh = r.U8();
    h.objectUuid = r.Fixed<uuidLenght>();
    h.interfaceUuid = r.Fixed<uuidLenght>();
    h.activityUuid = r.Fixed<uuidLenght>();
    h.serverBootTime = r.U32();
    h.interfaceVersion = r.U32();
    h.sequenceNumber = r.U32();
    h.operationNumber = r.U16();
    h.interfaceHint = r.U16();
    h.activityHint = r.U16();
    h.lengthOfBody = r.U16();
    h.fragmentNumber = r.U16();
    h.authenticationProtocol = r.U8();
    h.serialNrLow = r.U8();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
 
    // bool isLittleEndian = dataRepresentation[0] & 0x10;
 
    // auto putFieldU32 = [&](std::uint32_t value)
    // {
    //   if (isLittleEndian)
    //   {
    //     wire::PutLittleEndian(out, value);
    //   }
    //   else
    //   {
    //     wire::PutBigEndian(out, value);
    //   }
    // };
    // auto putFieldU16 = [&](std::uint16_t value)
    // {
    //   if (isLittleEndian)
    //   {
    //     wire::PutLittleEndian(out, value);
    //   }
    //   else
    //   {
    //     wire::PutBigEndian(out, value);
    //   }
    // };
 
    wire::PutU8(out, version);
    wire::PutU8(out, packetType);
    wire::PutU8(out, flags1);
    wire::PutU8(out, flags2);
    wire::PutFixed(out, dataRepresentation);
    wire::PutU8(out, serialNrHigh);
    wire::PutFixed(out, objectUuid);
    wire::PutFixed(out, interfaceUuid);
    wire::PutFixed(out, activityUuid);
 
    wire::PutU32(out, serverBootTime);
    wire::PutU32(out, interfaceVersion);
    wire::PutU32(out, sequenceNumber);
    wire::PutU16(out, operationNumber);
    wire::PutU16(out, interfaceHint);
    wire::PutU16(out, activityHint);
    wire::PutU16(out, lengthOfBody);
    wire::PutU16(out, fragmentNumber);
 
    // putFieldU32(serverBootTime); // server_boot_time
    // putFieldU32(interfaceVersion);
    // putFieldU32(sequenceNumber);
    // putFieldU16(operationNumber);
    // putFieldU16(interfaceHint); // interface_hint
    // putFieldU16(activityHint);  // activity_hint
    // putFieldU16(lengthOfBody);
    // putFieldU16(fragmentNumber); // fragment_number
    wire::PutU8(out, authenticationProtocol);
    wire::PutU8(out, serialNrLow);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
 
 private:
  static std::array<std::uint8_t, uuidLenght> PrefixedUuid(std::uint8_t b2, std::uint8_t b3)
  {
    std::array<std::uint8_t, uuidLenght> u{};
    u[0] = 0xDE;
    u[1] = 0xA0;
    u[2] = b2;
    u[3] = b3;
    std::ranges::copy(kPnUuidSuffix, u.begin() + 4);
    return u;
  }
};
 
struct PNNRDData
{
  std::uint32_t argsMaximumStatus = 0;
 
  std::uint32_t argsLength = 0;
 
  std::uint32_t maximumCount = 0;
 
  std::uint32_t offset = 0;
 
  std::uint32_t actualCount = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 20;
 
  static PNNRDData Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNNRDData: insufficient data");
    }
    wire::Reader r(data);
    PNNRDData d;
    d.argsMaximumStatus = r.U32();
    d.argsLength = r.U32();
    d.maximumCount = r.U32();
    d.offset = r.U32();
    d.actualCount = r.U32();
    // Some devices' actual_count doesn't exactly match the remaining
    // bytes (padding, etc.); take whichever is smaller
    std::size_t take = std::min<std::size_t>(d.actualCount, r.Remaining());
    d.payload = r.ReadBytes(take);
    return d;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU32(out, argsMaximumStatus);
    wire::PutU32(out, argsLength);
    wire::PutU32(out, maximumCount);
    wire::PutU32(out, offset);
    wire::PutU32(out, actualCount);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNIODHeader
{
  static constexpr std::uint16_t kContolCommandOffset = 28U;
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t sequenceNumber = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t padding1 = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t length = 0;
 
  std::array<std::uint8_t, uuidLenght> targetArUuid{};
 
  std::array<std::uint8_t, 8> padding2{};
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 64;
 
  static PNIODHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNIODHeader: insufficient data");
    }
    wire::Reader r(data);
    PNIODHeader h;
    h.blockHeader = r.Fixed<blockHeaderLength>();
    h.sequenceNumber = r.U16();
    h.arUuid = r.Fixed<uuidLenght>();
    h.api = r.U32();
    h.slot = r.U16();
    h.subslot = r.U16();
    h.padding1 = r.U16();
    h.index = r.U16();
    h.length = r.U32();
    h.targetArUuid = r.Fixed<uuidLenght>();
    h.padding2 = r.Fixed<8>();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, sequenceNumber);
    wire::PutFixed(out, arUuid);
    wire::PutU32(out, api);
    wire::PutU16(out, slot);
    wire::PutU16(out, subslot);
    wire::PutU16(out, padding1);
    wire::PutU16(out, index);
    wire::PutU32(out, length);
    wire::PutFixed(out, targetArUuid);
    wire::PutFixed(out, padding2);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNBlockHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr BlockType IODReadRequestHeader = BlockType::IoDataReadRequest; // 0x0009;
 
  static constexpr std::uint16_t IODReadResponseHeader = 0x8009;
 
  static constexpr std::uint16_t InM0 = 0x0020;
 
  static constexpr std::uint16_t InM0FilterDataSubModul = 0x0030;
 
  static constexpr std::uint16_t InM0FilterDataModul = 0x0031;
 
  static constexpr std::uint16_t InM0FilterDataDevice = 0x0032;
 
  static constexpr std::uint16_t DEFAULT_BLOCK_LENGTH = 60;
  // NOLINTEND(readability-identifier-naming)
 
  BlockType blockType;
 
  std::uint16_t blockLength = 0;
 
  std::uint16_t blockVersion = 0x0100;
 
  std::uint8_t blockVersionHigh = 1;
 
  std::uint8_t blockVersionLow = 0;
 
  static constexpr std::size_t kSize = sizeof(std::uint16_t) + sizeof(std::uint16_t) + (2 * sizeof(std::uint8_t));
 
  static PNBlockHeader Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNBlockHeader: insufficient data");
    }
    wire::Reader r(data);
    PNBlockHeader h;
    h.blockType = static_cast<BlockType>(r.U16());
    h.blockLength = r.U16();
    h.blockVersionHigh = r.U8();
    h.blockVersionLow = r.U8();
    r.SkipTo(4);
    h.blockVersion = r.U16();
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, static_cast<std::uint16_t>(blockType));
    wire::PutU16(out, blockLength);
    wire::PutU8(out, blockVersionHigh);
    wire::PutU8(out, blockVersionLow);
    return out;
  }
};
 
struct PNARBlockRequest
{
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t arType = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t sessionKey = 0;
 
  MacAddress cmInitiatorMacAddress{};
 
  std::array<std::uint8_t, uuidLenght> cmInitiatorObjectUuid{};
 
  std::uint32_t arProperties = 0;
 
  std::uint16_t cmInitiatorActivityTimeoutFactor = 0;
 
  std::uint16_t initiatorUdpRtport = 0;
 
  std::uint16_t stationNameLength = 0;
 
  Bytes cmInitiatorStationName;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 58;
 
  static PNARBlockRequest Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNARBlockRequest: insufficient data");
    }
    wire::Reader r(data);
    PNARBlockRequest b;
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.arType = r.U16();
    b.arUuid = r.Fixed<uuidLenght>();
    b.sessionKey = r.U16();
    b.cmInitiatorMacAddress = r.Fixed<macAddressLength>();
    b.cmInitiatorObjectUuid = r.Fixed<uuidLenght>();
    b.arProperties = r.U32();
    b.cmInitiatorActivityTimeoutFactor = r.U16();
    b.initiatorUdpRtport = r.U16();
    b.stationNameLength = r.U16();
    b.cmInitiatorStationName = r.ReadBytes(std::min<std::size_t>(b.stationNameLength, r.Remaining()));
    b.payload = r.ReadBytes(r.Remaining());
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, arType);
    wire::PutFixed(out, arUuid);
    wire::PutU16(out, sessionKey);
    wire::PutFixed(out, cmInitiatorMacAddress);
    wire::PutFixed(out, cmInitiatorObjectUuid);
    wire::PutU32(out, arProperties);
    wire::PutU16(out, cmInitiatorActivityTimeoutFactor);
    wire::PutU16(out, initiatorUdpRtport);
    wire::PutU16(out, stationNameLength);
    out.insert(out.end(), cmInitiatorStationName.begin(), cmInitiatorStationName.end());
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNIODReleaseBlock
{
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t padding1 = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint16_t sessionKey = 0;
 
  std::uint16_t padding2 = 0;
 
  ControlCommand controlCommand;
 
  std::uint16_t controlBlockProperties = 0;
 
  static constexpr std::size_t kSize = 32;
 
  static PNIODReleaseBlock Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNIODReleaseBlock: insufficient data");
    }
    wire::Reader r(data);
    PNIODReleaseBlock b;
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.padding1 = r.U16();
    b.arUuid = r.Fixed<uuidLenght>();
    b.sessionKey = r.U16();
    b.padding2 = r.U16();
    b.controlCommand = static_cast<ControlCommand>(r.U16());
    b.controlBlockProperties = r.U16();
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, padding1);
    wire::PutFixed(out, arUuid);
    wire::PutU16(out, sessionKey);
    wire::PutU16(out, padding2);
    wire::PutU16(out, static_cast<std::uint16_t>(controlCommand));
    wire::PutU16(out, controlBlockProperties);
    return out;
  }
};
 
// =============================================================================
// I&M (Identification & Maintenance) Data
// =============================================================================
 
struct PNInM0
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF0;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t vendorId = 0;
 
  // /// @brief High byte of the PROFINET vendor ID.
  // std::uint8_t vendorIdHigh = 0;
 
  // /// @brief Low byte of the PROFINET vendor ID.
  // std::uint8_t vendorIdLow = 0;
 
  std::string orderId;
 
  std::string imSerialNumber;
 
  std::uint16_t imHardwareRevision = 0;
 
  std::uint8_t swRevisionPrefix = 0;
 
  std::uint8_t imSwRevisionFunctionalEnhancement = 0;
 
  std::uint8_t imSwRevisionBugFix = 0;
 
  std::uint8_t imSwRevisionInternalChange = 0;
 
  std::uint16_t imRevisionCounter = 0;
 
  std::uint16_t imProfileId = 0;
 
  std::uint16_t imProfileSpecificType = 0;
 
  std::uint16_t imVersion = 0;
 
  std::uint16_t imSupported = 0;
 
  static constexpr std::size_t kSize = 60;
 
  [[nodiscard]] std::uint16_t VendorId() const
  {
    return vendorId;
  }
 
  static PNInM0 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM0: insufficient data");
    }
    wire::Reader r(data);
    PNInM0 v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    // v.vendorIdHigh = r.U8();
    // v.vendorIdLow = r.U8();
    v.vendorId = r.U16();
 
    auto oid = r.ReadBytes(20);
    v.orderId = DecodeBytes(oid);
    auto sn = r.ReadBytes(16);
    v.imSerialNumber = DecodeBytes(sn);
    v.imHardwareRevision = r.U16();
    v.swRevisionPrefix = r.U8();
    v.imSwRevisionFunctionalEnhancement = r.U8();
    v.imSwRevisionBugFix = r.U8();
    v.imSwRevisionInternalChange = r.U8();
    v.imRevisionCounter = r.U16();
    v.imProfileId = r.U16();
    v.imProfileSpecificType = r.U16();
    v.imVersion = r.U16();
    v.imSupported = r.U16();
    return v;
  }
 
  bool operator==(const PNInM0&) const = default;
};
 
struct PNInM1
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF1;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::string imTagFunction;
 
  std::string imTagLocation;
 
  static constexpr std::size_t kSize = 60;
 
  static PNInM1 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM1: insufficient data");
    }
    wire::Reader r(data);
    PNInM1 v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    v.imTagFunction = DecodeBytes(r.ReadBytes(32));
    v.imTagLocation = DecodeBytes(r.ReadBytes(22));
    return v;
  }
  bool operator==(const PNInM1&) const = default;
};
 
struct PNInM2
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF2;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::string imDate;
 
  static constexpr std::size_t kSize = 22;
 
  static PNInM2 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM2: insufficient data");
    }
    wire::Reader r(data);
    PNInM2 v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    v.imDate = DecodeBytes(r.ReadBytes(16));
    return v;
  }
 
  bool operator==(const PNInM2&) const = default;
};
 
struct PNInM3
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF3;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::string imDescriptor;
 
  static constexpr std::size_t kSize = 60;
 
  static PNInM3 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM3: insufficient data");
    }
    wire::Reader r(data);
    PNInM3 v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    v.imDescriptor = DecodeBytes(r.ReadBytes(54));
    return v;
  }
  bool operator==(const PNInM3&) const = default;
};
 
struct PNInM4
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF4;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::array<std::uint8_t, 54> imSignature{};
 
  static constexpr std::size_t kSize = 60;
 
  static PNInM4 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM4: insufficient data");
    }
    wire::Reader r(data);
    PNInM4 v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    v.imSignature = r.Fixed<54>();
    return v;
  }
  bool operator==(const PNInM4&) const = default;
};
 
struct PNInM5
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = 0xAFF5;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::string imAnnotation;
 
  static constexpr std::size_t kSize = 70;
 
  static PNInM5 Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNInM5: insufficient data");
    }
    wire::Reader r(data);
    PNInM5 v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    v.imAnnotation = DecodeBytes(r.ReadBytes(64));
    return v;
  }
  bool operator==(const PNInM5&) const = default;
};
 
template <std::uint16_t Idx>
struct PNInMReserved
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t IDX = Idx;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  Bytes payload;
 
  static PNInMReserved Parse(const Bytes& data)
  {
    if (data.size() < 6)
    {
      throw std::runtime_error("PNInMReserved: insufficient data");
    }
    wire::Reader r(data);
    PNInMReserved v;
    v.blockHeader = r.Fixed<blockHeaderLength>();
    v.payload = r.ReadBytes(r.Remaining());
    return v;
  }
 
  bool operator==(const PNInMReserved&) const = default;
};
 
using PNInM6 = PNInMReserved<0xAFF6>;
using PNInM7 = PNInMReserved<0xAFF7>;
using PNInM8 = PNInMReserved<0xAFF8>;
using PNInM9 = PNInMReserved<0xAFF9>;
using PNInM10 = PNInMReserved<0xAFFA>;
using PNInM11 = PNInMReserved<0xAFFB>;
using PNInM12 = PNInMReserved<0xAFFC>;
using PNInM13 = PNInMReserved<0xAFFD>;
using PNInM14 = PNInMReserved<0xAFFE>;
using PNInM15 = PNInMReserved<0xAFFF>;
 
// =============================================================================
// IOCR (IO Connection Relationship) Blocks
// =============================================================================
 
struct IOCRAPIObject
{
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint16_t frameOffset = 0;
 
  static constexpr std::size_t kSize = 6;
 
  static IOCRAPIObject Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("IOCRAPIObject: insufficient data");
    }
    wire::Reader r(data);
    IOCRAPIObject o;
    o.slotNumber = r.U16();
    o.subslotNumber = r.U16();
    o.frameOffset = r.U16();
    return o;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, slotNumber);
    wire::PutU16(out, subslotNumber);
    wire::PutU16(out, frameOffset);
    return out;
  }
};
 
struct PNIOCRBlockRes
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x8102;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t iocrType = 0;
 
  std::uint16_t iocrReference = 0;
 
  std::uint16_t frameId = 0;
 
  static constexpr std::size_t kSize = 12;
 
  static PNIOCRBlockRes Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNIOCRBlockRes: insufficient data");
    }
    wire::Reader r(data);
    PNIOCRBlockRes b;
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.iocrType = r.U16();
    b.iocrReference = r.U16();
    b.frameId = r.U16();
    return b;
  }
};
 
struct PNIOCRBlockReqHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr BlockType BLOCK_TYPE = BlockType::IoCrRequest;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t iocrType = 0;
 
  std::uint16_t iocrReference = 0;
 
  std::uint16_t etherTypeLT = PROFINET_ETHERTYPE;
 
  std::uint32_t iocrProperties = 0;
 
  std::uint16_t dataLength = 0;
 
  std::uint16_t frameId = 0;
 
  std::uint16_t sendClockFactor = 32;
 
  std::uint16_t reductionRatio = 1;
 
  std::uint16_t phase = 1;
 
  std::uint16_t sequence = 0;
 
  std::uint32_t frameSendOffset = 0;
 
  std::uint16_t watchdogFactor = 3;
 
  std::uint16_t dataHoldFactor = 3;
 
  std::uint16_t iocrTagHeader = 0xC000;
 
  MacAddress iocrMulticastMac{};
 
  std::uint16_t numberOfApis = 1;
 
  static constexpr std::size_t kSize = 46;
 
  [[nodiscard]] static PNIOCRBlockReqHeader Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error(
          "IOCRBlockReq too short, insufficient data: " +
          std::to_string(data.size()) +
          " bytes, expected at least " +
          std::to_string(kSize));
    }
 
    wire::Reader r(data);
    PNIOCRBlockReqHeader b;
 
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.iocrType = r.U16();
    b.iocrReference = r.U16();
    b.etherTypeLT = r.U16();
    b.iocrProperties = r.U32();
    b.dataLength = r.U16();
    b.frameId = r.U16();
    b.sendClockFactor = r.U16();
    b.reductionRatio = r.U16();
    b.phase = r.U16();
    b.sequence = r.U16();
    b.frameSendOffset = r.U32();
    b.watchdogFactor = r.U16();
    b.dataHoldFactor = r.U16();
    b.iocrTagHeader = r.U16();
    b.iocrMulticastMac = r.Fixed<macAddressLength>();
    b.numberOfApis = r.U16();
 
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, iocrType);
    wire::PutU16(out, iocrReference);
    wire::PutU16(out, etherTypeLT);
    wire::PutU32(out, iocrProperties);
    wire::PutU16(out, dataLength);
    wire::PutU16(out, frameId);
    wire::PutU16(out, sendClockFactor);
    wire::PutU16(out, reductionRatio);
    wire::PutU16(out, phase);
    wire::PutU16(out, sequence);
    wire::PutU32(out, frameSendOffset);
    wire::PutU16(out, watchdogFactor);
    wire::PutU16(out, dataHoldFactor);
    wire::PutU16(out, iocrTagHeader);
    wire::PutFixed(out, iocrMulticastMac);
    wire::PutU16(out, numberOfApis);
    return out;
  }
};
 
// =============================================================================
// AlarmCR (Alarm Connection Relationship) Blocks
// =============================================================================
 
struct PNAlarmCRBlockReq
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr BlockType BLOCK_TYPE = BlockType::AlarmCrRequest;
 
  static constexpr std::uint16_t DEFAULT_RTA_TIMEOUT_FACTOR = 1;
 
  static constexpr std::uint16_t DEFAULT_RTA_RETRIES = 3;
 
  static constexpr std::uint16_t DEFAULT_MAX_ALARM_DATA_LENGTH = 200;
 
  static constexpr std::uint16_t DEFAULT_TAG_HEADER_HIGH = 0xC000;
 
  static constexpr std::uint16_t DEFAULT_TAG_HEADER_LOW = 0xA000;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t alarmCrType = 1;
 
  std::uint16_t etherTypeLT = 0x8892;
 
  std::uint32_t alarmCrProperties = 0;
 
  std::uint16_t rtaTimeoutFactor = DEFAULT_RTA_TIMEOUT_FACTOR;
 
  std::uint16_t rtaRetries = DEFAULT_RTA_RETRIES;
 
  std::uint16_t localAlarmReference = 0;
 
  std::uint16_t maxAlarmDataLength = DEFAULT_MAX_ALARM_DATA_LENGTH;
 
  std::uint16_t alarmCrTagHeaderHigh = DEFAULT_TAG_HEADER_HIGH;
 
  std::uint16_t alarmCrTagHeaderLow = DEFAULT_TAG_HEADER_LOW;
 
  static constexpr std::size_t kSize = 26;
 
  static PNAlarmCRBlockReq Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNAlarmCRBlockReq: insufficient data");
    }
 
    wire::Reader r(data);
    PNAlarmCRBlockReq b;
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.alarmCrType = r.U16();
    b.etherTypeLT = r.U16();
    b.alarmCrProperties = r.U32();
    b.rtaTimeoutFactor = r.U16();
    b.rtaRetries = r.U16();
    b.localAlarmReference = r.U16();
    b.maxAlarmDataLength = r.U16();
    b.alarmCrTagHeaderHigh = r.U16();
    b.alarmCrTagHeaderLow = r.U16();
 
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, alarmCrType);
    wire::PutU16(out, etherTypeLT);
    wire::PutU32(out, alarmCrProperties);
    wire::PutU16(out, rtaTimeoutFactor);
    wire::PutU16(out, rtaRetries);
    wire::PutU16(out, localAlarmReference);
    wire::PutU16(out, maxAlarmDataLength);
    wire::PutU16(out, alarmCrTagHeaderHigh);
    wire::PutU16(out, alarmCrTagHeaderLow);
    return out;
  }
};
 
struct PNAlarmCRBlockRes
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x8103;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t alarmCrType = 0;
 
  std::uint16_t localAlarmReference = 0;
 
  std::uint16_t maxAlarmDataLength = 0;
 
  static constexpr std::size_t kSize = 12;
 
  static PNAlarmCRBlockRes Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNAlarmCRBlockRes: insufficient data");
    }
    wire::Reader r(data);
    PNAlarmCRBlockRes b;
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.alarmCrType = r.U16();
    b.localAlarmReference = r.U16();
    b.maxAlarmDataLength = r.U16();
    return b;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
 
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, alarmCrType);
    wire::PutU16(out, localAlarmReference);
    wire::PutU16(out, maxAlarmDataLength);
 
    return out;
  }
};
 
// =============================================================================
// Alarm Notification PDUs
// =============================================================================
 
struct PNAlarmNotificationPDU
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_ALARM_HIGH = 0x0001;
 
  static constexpr std::uint16_t BLOCK_ALARM_LOW = 0x0002;
 
  static constexpr std::uint16_t BLOCK_ALARM_ACK_HIGH = 0x8001;
 
  static constexpr std::uint16_t BLOCK_ALARM_ACK_LOW = 0x8002;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t alarmType = 0;
 
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint32_t moduleIdentNumber = 0;
 
  std::uint32_t submoduleIdentNumber = 0;
 
  std::uint16_t alarmSpecifier = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 26;
 
  static PNAlarmNotificationPDU Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNAlarmNotificationPDU: insufficient data");
    }
    wire::Reader r(data);
    PNAlarmNotificationPDU p;
    p.blockHeader = r.Fixed<blockHeaderLength>();
    p.alarmType = r.U16();
    p.api = r.U32();
    p.slotNumber = r.U16();
    p.subslotNumber = r.U16();
    p.moduleIdentNumber = r.U32();
    p.submoduleIdentNumber = r.U32();
    p.alarmSpecifier = r.U16();
    p.payload = r.ReadBytes(r.Remaining());
    return p;
  }
};
 
struct PNAlarmAckPDU
{
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  AlarmType alarmType;
 
  std::uint32_t api = 0;
 
  std::uint16_t slotNumber = 0;
 
  std::uint16_t subslotNumber = 0;
 
  std::uint16_t alarmSpecifier = 0;
 
  std::uint32_t statusPNIO = 0;
 
  static constexpr std::size_t kSize = 22;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, static_cast<std::uint16_t>(alarmType));
    wire::PutU32(out, api);
    wire::PutU16(out, slotNumber);
    wire::PutU16(out, subslotNumber);
    wire::PutU16(out, alarmSpecifier);
    wire::PutU32(out, statusPNIO);
    return out;
  }
};
 
struct PNRTAHeader
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint8_t RTA_TYPE_DATA = 0x01;
 
  static constexpr std::uint8_t RTA_TYPE_NACK = 0x02;
 
  static constexpr std::uint8_t RTA_TYPE_ACK = 0x03;
 
  static constexpr std::uint8_t RTA_TYPE_ERR = 0x04;
 
  static constexpr std::uint8_t VERSION_1 = 0x01;
 
  static constexpr std::uint8_t VERSION_2 = 0x02;
 
  static constexpr std::uint8_t ADD_FLAGS_WINDOW_1 = 0x01;
 
  static constexpr std::uint8_t ADD_FLAGS_TACK = 0x10;
 
  // NOLINTEND(readability-identifier-naming)
 
  std::uint16_t alarmDstEndpoint = 0;
 
  std::uint16_t alarmSrcEndpoint = 0;
 
  std::uint8_t pduType = 0;
 
  std::uint8_t addFlags = 0;
 
  std::uint16_t sendSeqNum = 0;
 
  std::uint16_t ackSeqNum = 0;
 
  std::uint16_t variablePartLenght = 0;
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 12;
 
  static PNRTAHeader Parse(const Bytes& data)
  {
    if (data.size() < kFixedSize)
    {
      throw std::runtime_error("PNRTAHeader: insufficient data");
    }
    wire::Reader r(data);
    PNRTAHeader h;
    h.alarmDstEndpoint = r.U16();
    h.alarmSrcEndpoint = r.U16();
    h.pduType = r.U8();
    h.addFlags = r.U8();
    h.sendSeqNum = r.U16();
    h.ackSeqNum = r.U16();
    h.variablePartLenght = r.U16();
    h.payload = r.ReadBytes(r.Remaining());
    return h;
  }
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, alarmDstEndpoint);
    wire::PutU16(out, alarmSrcEndpoint);
    wire::PutU8(out, pduType);
    wire::PutU8(out, addFlags);
    wire::PutU16(out, sendSeqNum);
    wire::PutU16(out, ackSeqNum);
    wire::PutU16(out, variablePartLenght);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
enum class RtaErrorClass : std::uint8_t
{
  Reserved = 0x00,
 
  SequenceNumber = 0x01,
 
  Abort = 0x02,
 
  Extended = 0x03,
 
  Obsoleted = 0x04,
 
  UserSpecific = 0x05,
};
 
enum class RtaErrorReason : std::uint8_t
{
  Reserved = 0x00,
  SequenceNumber = 0x01,
 
  InstanceClosed = 0x02,
  ArOutOfMemory = 0x03,
  ArAddProviderConsumerFailed = 0x04,
  ArConsumerDhtWdtExpired = 0x05,
  ArCmiTimeout = 0x06,
  ArAlarmOpenFailed = 0x07,
  ArAlarmSendConfirmationNegative = 0x08,
  ArAlarmAckSendConfirmationNegative = 0x09,
  ArAlarmDataTooLong = 0x0A,
  ArAlarmIndError = 0x0B,
  ArRpcClientCallConfirmationNegative = 0x0C,
  ArAbortRequest = 0x0D,
  ArRerunAbortsExisting = 0x0E,
  ArReleaseIndReceived = 0x0F,
  ArDeviceDeactivated = 0x10,
  ArRemoved = 0x11,
  ArProtocolViolation = 0x12,
  ArNameResolutionError = 0x13,
  ArRpcBindError = 0x14,
  ArRpcConnectError = 0x15,
  ArRpcReadError = 0x16,
  ArRpcWriteError = 0x17,
  ArRpcControlError = 0x18,
  ArForbiddenPullPlug = 0x19,
  ArApRemoved = 0x1A,
  ArLinkDown = 0x1B,
  ArMulticastMacRegistrationFailed = 0x1C,
  NotSynchronized = 0x1D,
  WrongTopology = 0x1E,
  DcpStationNameChanged = 0x1F,
  DcpResetToFactorySettings = 0x20,
  CompanionAr8ippSubmodule = 0x21,
  NoIrdataRecordYet = 0x22,
  Pdev = 0x23,
  PdevNoRequiredSpeedDuplexity = 0x24,
  IpSuiteChanged = 0x25,
  IocarSrRdhtExpired = 0x26,
  IocarSrPdevParameterizationImpossible = 0x27,
  RemoteApplicationReadyTimeout = 0x28,
  IocarSrRedundantInterfaceLost = 0x29,
  IocarSrMtotExpired = 0x2A,
  IocarSrArProtocolViolation = 0x2B,
  PdevPlugPortWithoutCombinedObjectContainer = 0x2C,
  ObsoletedNmeNoConfiguration = 0x2D,
 
  UserAbort = 0xFF,
};
 
struct RtaError
{
  PNRTAHeader header;
 
  std::uint32_t statusPnio = 0;
 
  std::uint8_t errorCode = 0;
 
  std::uint8_t errorDecode = 0;
 
  std::uint8_t errorCode1 = 0;
 
  std::uint8_t errorCode2 = 0;
 
  RtaErrorReason reason = RtaErrorReason::Reserved;
 
  RtaErrorClass kind = RtaErrorClass::UserSpecific;
 
  [[nodiscard]] RtaErrorClass ErrorClass() const
  {
    return kind;
  }
 
  [[nodiscard]] bool IsRtaProtocolError() const
  {
    return errorCode == 0xCFU &&
           errorDecode == 0x81U &&
           errorCode1 == 0xFDU;
  }
 
  [[nodiscard]] bool IsSequenceNumberError() const
  {
    return IsRtaProtocolError() &&
           errorCode2 == 0x01U;
  }
 
  [[nodiscard]] bool IsAbort() const
  {
    return IsRtaProtocolError() &&
           errorCode2 >= 0x02U &&
           errorCode2 <= 0x25U;
  }
 
  [[nodiscard]] bool IsExtended() const
  {
    return IsRtaProtocolError() &&
           errorCode2 >= 0x26U &&
           errorCode2 <= 0x2CU;
  }
 
  [[nodiscard]] bool IsObsoleted() const
  {
    return IsRtaProtocolError() &&
           errorCode2 == 0x2DU;
  }
 
  [[nodiscard]] bool IsUserAbort() const
  {
    return IsRtaProtocolError() &&
           errorCode2 == 0xFFU;
  }
 
  [[nodiscard]] std::string ReasonName() const;
 
  static RtaErrorReason ClassifyRtaErrorReason(std::uint8_t errorCode2);
 
  static RtaErrorClass ClassifyRtaError(std::uint8_t errorCode2);
 
  static RtaErrorClass ClassifyRtaError(RtaErrorReason reason);
};
 
[[nodiscard]] inline RtaError ParseRtaError(const PNRTAHeader& header)
{
  const auto rtaType = static_cast<std::uint8_t>(header.pduType & 0x0FU);
 
  if (rtaType != PNRTAHeader::RTA_TYPE_ERR)
  {
    throw std::invalid_argument("RTA PDU is not ERR-RTA");
  }
 
  if (header.variablePartLenght != 4U)
  {
    throw std::invalid_argument("RTA ERR-PDU variable part must be 4 bytes");
  }
 
  if (header.payload.size() < header.variablePartLenght)
  {
    throw std::invalid_argument("Truncated RTA ERR-PDU payload");
  }
 
  RtaError result;
  result.header = header;
 
  result.errorCode = header.payload[0];
  result.errorDecode = header.payload[1];
  result.errorCode1 = header.payload[2];
  result.errorCode2 = header.payload[3];
 
  result.statusPnio =
      (static_cast<std::uint32_t>(result.errorCode) << 24U) |
      (static_cast<std::uint32_t>(result.errorDecode) << 16U) |
      (static_cast<std::uint32_t>(result.errorCode1) << 8U) |
      static_cast<std::uint32_t>(result.errorCode2);
  result.reason = RtaError::ClassifyRtaErrorReason(result.errorCode2);
  result.kind = RtaError::ClassifyRtaError(result.errorCode2);
  return result;
}
 
[[nodiscard]] inline RtaError ParseRtaError(const Bytes& data)
{
  return ParseRtaError(PNRTAHeader::Parse(data));
}
 
// =============================================================================
// ExpectedSubmodule Blocks (0x0104)
// =============================================================================
 
struct PNExpectedSubmoduleDataDescription
{
  std::uint16_t dataDescription = 0;
 
  std::uint16_t submoduleDataLength = 0;
 
  std::uint8_t lengthIocs = 0;
 
  std::uint8_t lengthIops = 0;
 
  static constexpr std::size_t kSize = 6;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutU16(out, dataDescription);
    wire::PutU16(out, submoduleDataLength);
    wire::PutU8(out, lengthIocs);
    wire::PutU8(out, lengthIops);
    return out;
  }
};
 
// =============================================================================
// IOD Write/Read Request Blocks
// =============================================================================
 
struct PNIODWriteReq
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x0008;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t seqNum = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t padding = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t recordDataLength = 0;
 
  std::array<std::uint8_t, 24> rwPadding{};
 
  Bytes payload;
 
  static constexpr std::size_t kFixedSize = 64;
 
  [[nodiscard]] Bytes ToBytes() const
  {
    Bytes out;
    wire::PutFixed(out, blockHeader);
    wire::PutU16(out, seqNum);
    wire::PutFixed(out, arUuid);
    wire::PutU32(out, api);
    wire::PutU16(out, slot);
    wire::PutU16(out, subslot);
    wire::PutU16(out, padding);
    wire::PutU16(out, index);
    wire::PutU32(out, recordDataLength);
    wire::PutFixed(out, rwPadding);
    out.insert(out.end(), payload.begin(), payload.end());
    return out;
  }
};
 
struct PNIODWriteRes
{
  // NOLINTBEGIN(readability-identifier-naming)
  static constexpr std::uint16_t BLOCK_TYPE = 0x8008;
  // NOLINTEND(readability-identifier-naming)
 
  std::array<std::uint8_t, blockHeaderLength> blockHeader{};
 
  std::uint16_t seqNum = 0;
 
  std::array<std::uint8_t, uuidLenght> arUuid{};
 
  std::uint32_t api = 0;
 
  std::uint16_t slot = 0;
 
  std::uint16_t subslot = 0;
 
  std::uint16_t padding = 0;
 
  std::uint16_t index = 0;
 
  std::uint32_t recordDataLength = 0;
 
  std::uint16_t additionalValue1 = 0;
 
  std::uint16_t additionalValue2 = 0;
 
  std::uint32_t status = 0;
 
  std::array<std::uint8_t, 16> rwPadding{};
 
  static constexpr std::size_t kSize = 64;
 
  static PNIODWriteRes Parse(const Bytes& data)
  {
    if (data.size() < kSize)
    {
      throw std::runtime_error("PNIODWriteRes: insufficient data");
    }
    wire::Reader r(data);
    PNIODWriteRes b;
    b.blockHeader = r.Fixed<blockHeaderLength>();
    b.seqNum = r.U16();
    b.arUuid = r.Fixed<uuidLenght>();
    b.api = r.U32();
    b.slot = r.U16();
    b.subslot = r.U16();
    b.padding = r.U16();
    b.index = r.U16();
    b.recordDataLength = r.U32();
    b.additionalValue1 = r.U16();
    b.additionalValue2 = r.U16();
    b.status = r.U32();
    b.rwPadding = r.Fixed<16>();
    return b;
  }
};
 
} // namespace profinet