dcp.cpp

Go to the documentation of this file.

 
 
#include "profinet/dcp.h"
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <magic_enum.hpp>
#include <map>
#include <random>
#include <thread>
 
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
#include "profinet/vendors.h"
 
namespace profinet::dcp
{
 
namespace
{
 
std::uint32_t GenerateXid()
{
  static thread_local std::mt19937 rng{std::random_device{}()};
  static constexpr std::size_t maxXid = 0xFFFFFFFFULL;
  static thread_local std::uniform_int_distribution<std::uint64_t> dist(0, maxXid);
  return static_cast<std::uint32_t>(dist(rng));
}
 
template <typename Fn>
void ForEachBlock(const std::vector<std::uint8_t>& data, Fn&& fn)
{
  wire::Reader r(data);
 
  while (r.Remaining() >= 4U)
  {
    const auto option = static_cast<DcpOption>(r.U8());
    const auto suboption = r.U8();
    const auto length = r.U16();
 
    const std::size_t payloadLength =
        std::min<std::size_t>(length, r.Remaining());
 
    const Bytes payload = r.ReadBytes(payloadLength);
 
    fn(option, suboption, payload);
 
    if (payloadLength < length)
    {
      break;
    }
 
    if ((length % 2U) != 0U)
    {
      if (r.Remaining() < sizeof(std::uint8_t))
      {
        break;
      }
 
      r.Skip(sizeof(std::uint8_t));
    }
  }
}
} // namespace
 
std::vector<std::string> DecodeDeviceRole(std::uint8_t roleByte)
{
  std::vector<std::string> roles;
 
  for (const auto role : magic_enum::enum_values<DcpDeviceRole>())
  {
    const auto mask = static_cast<std::uint8_t>(role);
 
    if ((roleByte & mask) != 0U)
    {
      roles.emplace_back(magic_enum::enum_name(role));
    }
  }
 
  if (roles.empty())
  {
    roles.emplace_back("Unknown");
  }
 
  return roles;
}
std::string DeviceRoleName(DcpDeviceRole role)
{
  return magic_enum::enum_contains(role)
             ? std::string(magic_enum::enum_name(role))
             : "Unknown";
}
 
std::string GetSuboptionName(std::uint16_t option, std::uint8_t value)
{
  const auto dcpOption = static_cast<DcpOption>(option);
  if (magic_enum::enum_contains(dcpOption))
  {
    switch (dcpOption)
    {
      case DcpOption::Ip:
      {
        const auto suboption = static_cast<DcpIpSuboption>(value);
 
        if (magic_enum::enum_contains(suboption))
        {
          return std::string{magic_enum::enum_name(suboption)};
        }
        break;
      }
 
      case DcpOption::Device:
      {
        const auto suboption = static_cast<DcpDeviceSuboption>(value);
 
        if (magic_enum::enum_contains(suboption))
        {
          return std::string{magic_enum::enum_name(suboption)};
        }
        break;
      }
 
      case DcpOption::Dhcp:
      {
        const auto suboption = static_cast<DcpDhcpSuboption>(value);
 
        if (magic_enum::enum_contains(suboption))
        {
          return std::string{magic_enum::enum_name(suboption)};
        }
        break;
      }
 
      case DcpOption::Control:
      {
        const auto suboption = static_cast<DcpControlSuboption>(value);
 
        if (magic_enum::enum_contains(suboption))
        {
          return std::string{magic_enum::enum_name(suboption)};
        }
        break;
      }
 
      case DcpOption::DeviceInitiative:
      {
        const auto suboption = static_cast<DcpDeviceInitiativeSuboption>(value);
 
        if (magic_enum::enum_contains(suboption))
        {
          return std::string{magic_enum::enum_name(suboption)};
        }
        break;
      }
      case DcpOption::Unknown:
      case DcpOption::Reserved:
      case DcpOption::Nme:
      case DcpOption::All:
        break;
    }
  }
  return Hex2(value);
}
 
std::string GetBlockName(std::uint16_t option, std::uint8_t suboption)
{
  std::string optionName;
  const auto dcpOption = static_cast<DcpOption>(option);
 
  if (magic_enum::enum_contains(dcpOption) && dcpOption != DcpOption::Unknown)
  {
    optionName = std::string{magic_enum::enum_name(dcpOption)};
  }
  else
  {
    if (option >= blockNameVendorRangeMin && option <= blockNameVendorRangeMax)
    {
      optionName = "Vendor-" + Hex2(option);
    }
    else
    {
      optionName = "Opt-" + Hex2(option);
    }
  }
 
  const auto suboptionName = GetSuboptionName(option, suboption);
 
  return optionName + "/" + suboptionName;
}
 
std::string GetBlockName(DcpOption option, std::uint8_t suboption)
{
  return GetBlockName(static_cast<std::uint16_t>(option), suboption);
}
 
std::string GetBlockName(DcpOption option, DcpIpSuboption suboption)
{
  return GetBlockName(option, static_cast<std::uint8_t>(suboption));
}
 
std::string GetBlockName(DcpOption option, DcpDeviceSuboption suboption)
{
  return GetBlockName(option, static_cast<std::uint8_t>(suboption));
}
 
std::string GetBlockName(DcpOption option, DcpControlSuboption suboption)
{
  return GetBlockName(option, static_cast<std::uint8_t>(suboption));
}
 
std::string GetBlockName(DcpOption option, DcpDhcpSuboption suboption)
{
  return GetBlockName(option, static_cast<std::uint8_t>(suboption));
}
 
std::string GetBlockName(DcpOption option, DcpDeviceInitiativeSuboption suboption)
{
  return GetBlockName(option, static_cast<std::uint8_t>(suboption));
}
 
DcpBlockError RecvSetResponse(IRawEthernetSocket& sock, const MacAddress& srcMac, int timeoutSec)
{
  sock.SetTimeout(std::chrono::milliseconds(2000));
  const MaxTimeout timer{std::chrono::duration<double>(timeoutSec)};
  while (!timer.TimedOut())
  {
    const Bytes data = sock.Recv();
    if (data.empty() || data.size() < 14)
    {
      continue;
    }
 
    EthernetHeader eth;
    try
    {
      eth = EthernetHeader::Parse(data);
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    if (eth.dst != srcMac)
    {
      continue;
    }
 
    Bytes payload = eth.payload;
 
    if (eth.type == VLAN_ETHERTYPE)
    {
      if (payload.size() < 2 * sizeof(std::uint16_t))
      {
        continue;
      }
      wire::Reader r(payload);
      r.Skip(sizeof(std::uint16_t));
      const auto innerType = r.U16();
      if (innerType != PROFINET_ETHERTYPE)
      {
        continue;
      }
    }
    else if (eth.type != PROFINET_ETHERTYPE)
    {
      continue;
    }
 
    try
    {
      return ParseSetResponse(data);
    }
    catch (const DCPError& e)
    {
      if (std::string(e.what()).find("unexpected service_type") != std::string::npos)
      {
        continue;
      }
      throw;
    }
  }
  throw DCPTimeoutError("No DCP SET response received");
}
 
DcpBlockError ParseSetResponse(const Bytes& data)
{
  if (data.size() < 14)
  {
    throw DCPError("DCP SET response too short");
  }
 
  EthernetHeader eth;
  try
  {
    eth = EthernetHeader::Parse(data);
  }
  catch (const std::exception& e)
  {
    throw DCPError(std::string("Failed to parse Ethernet header: ") + e.what());
  }
 
  Bytes payload = eth.payload;
  if (eth.type == VLAN_ETHERTYPE)
  {
    if (payload.size() < 2 * sizeof(std::uint16_t))
    {
      throw DCPError("VLAN frame too short");
    }
    wire::Reader r(payload);
    r.Skip(sizeof(std::uint16_t));
    const auto innerType = r.U16();
 
    if (innerType != PROFINET_ETHERTYPE)
    {
      throw DCPError("Unexpected inner EtherType: " + Hex4(innerType));
    }
    payload = Bytes(payload.begin() + 4, payload.end());
  }
  else if (eth.type != PROFINET_ETHERTYPE)
  {
    throw DCPError("Unexpected EtherType: " + Hex4(eth.type));
  }
 
  PNDCPHeader hdr;
  try
  {
    hdr = PNDCPHeader::Parse(payload);
  }
  catch (const std::exception& e)
  {
    throw DCPError(std::string("Failed to parse DCP header: ") + e.what());
  }
 
  if (hdr.serviceType == DcpServiceType::ResponseUnsupported)
  {
    throw DCPError("DCP SET: service not supported by device");
  }
  if (hdr.serviceType != DcpServiceType::ResponseSuccess)
  {
    throw DCPError("DCP SET: unexpected service_type " + Hex2(static_cast<std::uint8_t>(hdr.serviceType)));
  }
 
  DcpBlockError result = DcpBlockError::Ok;
  bool found = false;
  ForEachBlock(hdr.payload, [&](DcpOption option, std::uint8_t suboption, const Bytes& blockPayload)
  {
    if (found)
    {
      return;
    }
    if (option == DcpOption::Control && static_cast<DcpControlSuboption>(suboption) == DcpControlSuboption::Response)
    {
      found = true;
      if (blockPayload.size() >= 3)
      {
        result = static_cast<DcpBlockError>(blockPayload[2]);
      }
      else if (!blockPayload.empty())
      {
        result = static_cast<DcpBlockError>(blockPayload[0]);
      }
    }
  });
  // No Control/Response block found - some devices omit it; treat as success.
  return result;
}
 
std::string GetIPBlockInfoName(DcpIpBlockInfo info)
{
  switch (info)
  {
    case DcpIpBlockInfo::NotSet:
      return "IP not set";
    case DcpIpBlockInfo::Set:
      return "IP set";
    case DcpIpBlockInfo::SetByDhcp:
      return "IP set by DHCP";
    case DcpIpBlockInfo::NotSetConflict:
      return "IP not set (address conflict detected)";
    case DcpIpBlockInfo::SetConflict:
      return "IP set (address conflict detected)";
    case DcpIpBlockInfo::SetByDhcpConflict:
      return "IP set by DHCP (address conflict detected)";
 
    default:
      return "Unknown (" + Hex4(static_cast<std::uint16_t>(info)) + ")";
  }
}
 
bool HasConflict(DcpIpBlockInfo info)
{
  return (static_cast<std::uint16_t>(info) & DCP_IP_CONFLICT_BIT) != 0U;
}
 
bool IsDhcp(DcpIpBlockInfo info)
{
  return (static_cast<std::uint16_t>(info) & DCP_IP_DHCP_BIT) != 0U;
}
 
std::string GetDcpBlockQualifierDescription(DcpBlockQualifier qualifier)
{
  const auto name = magic_enum::enum_name(qualifier);
 
  if (!name.empty())
  {
    return std::string{name};
  }
 
  return "Unknown (" +
         Hex4(static_cast<std::uint16_t>(qualifier)) + ")";
}
 
std::string GetResetQualifierName(std::uint16_t qualifier)
{
  auto resetQualifier = magic_enum::enum_cast<DcpResetQualifier>(qualifier);
  if (resetQualifier.has_value())
  {
    return GetResetQualifierName(resetQualifier.value());
  }
  return "Unknown (" + Hex4(qualifier) + ")";
}
 
std::string GetResetQualifierName(DcpResetQualifier qualifier)
{
  switch (qualifier)
  {
    case DcpResetQualifier::ApplicationData:
    case DcpResetQualifier::ApplicationDataAlternate:
      return "Reset application data";
    case DcpResetQualifier::CommunicationParameter:
    case DcpResetQualifier::CommunicationParameterAlternate:
      return "Reset communication parameter";
    case DcpResetQualifier::EngineeringParameter:
    case DcpResetQualifier::EngineeringParameterAlternate:
      return "Reset engineering parameter";
    case DcpResetQualifier::AllStoredData:
    case DcpResetQualifier::AllStoredDataAlternate:
      return "Reset all stored data";
 
    case DcpResetQualifier::EngineeringParameterExtended:
    case DcpResetQualifier::EngineeringParameterExtendedAlternate:
      return "Reset engineering parameter";
    case DcpResetQualifier::ToFactory:
    case DcpResetQualifier::ToFactoryAlternate:
      return "Reset to factory values";
    case DcpResetQualifier::Restore:
    case DcpResetQualifier::RestoreAlternate:
      return "Reset and restore data";
    default:
      return "Unknown (" + Hex4(static_cast<std::uint16_t>(qualifier)) + ")";
  }
}
 
std::string GetDeviceInitiativeName(DcpDeviceInitiative value)
{
  switch (value)
  {
    case DcpDeviceInitiative::NoHello:
      return "Device does not issue DCP-Hello after power on";
    case DcpDeviceInitiative::IssueHello:
      return "Device issues DCP-Hello after power on";
    default:
      return "Unknown (" + Hex4(static_cast<std::uint16_t>(value)) + ")";
  }
}
 
std::string GetDcpResponseCodeName(DcpResponseCode value)
{
  switch (value)
  {
    case DcpResponseCode::NoError:
      return "No error";
    case DcpResponseCode::OptionNotSupported:
      return "Option not supported";
    case DcpResponseCode::SuboptionNotSupported:
      return "Suboption not supported or no DataSet available";
    case DcpResponseCode::SuboptionNotSet:
      return "Suboption not set";
    case DcpResponseCode::ResourceError:
      return "Resource error";
    case DcpResponseCode::SetNotPossible:
      return "Set not possible";
    case DcpResponseCode::InOperationSetNotPossible:
      return "In operation, SET not possible";
    default:
      return "Unknown (" + Hex2(static_cast<std::uint8_t>(value)) + ")";
  }
}
 
std::string GetDcpBlockErrorDescription(DcpBlockError error)
{
  switch (error)
  {
    case DcpBlockError::Ok:
      return "Ok";
 
    case DcpBlockError::OptionUnsupported:
      return "Option not supported";
 
    case DcpBlockError::SuboptionUnsupported:
      return "Suboption not supported or no dataset available";
 
    case DcpBlockError::SuboptionNotSet:
      return "Suboption not set";
 
    case DcpBlockError::Resource:
      return "Resource error";
 
    case DcpBlockError::SetNotPossible:
      return "SET not possible by local reasons";
 
    case DcpBlockError::InOperation:
      return "In operation, SET not possible";
  }
 
  return "Unknown error (" + Hex2(static_cast<std::uint8_t>(error)) + ")";
}
 
DCPDHCPBlock DCPDHCPBlock::Parse(DcpDhcpSuboption suboption, const std::vector<std::uint8_t>& data)
{
  DCPDHCPBlock block;
  block.suboption = suboption;
  block.suboptionName = suboption != DcpDhcpSuboption::Unknown && magic_enum::enum_contains(suboption)
                            ? std::string{magic_enum::enum_name(suboption)}
                            : Hex2(static_cast<std::uint8_t>(suboption));
 
  block.rawData = data;
 
  if (suboption == DcpDhcpSuboption::Hostname)
  {
    block.hostname = DecodeBytes(data);
  }
  else if (suboption == DcpDhcpSuboption::ClientId)
  {
    block.clientId = data;
  }
  else if (suboption == DcpDhcpSuboption::VendorSpec)
  {
    block.vendorSpecific = data;
  }
  else if (suboption == DcpDhcpSuboption::Fqdn)
  {
    block.fqdn = DecodeBytes(data);
  }
  else if (suboption == DcpDhcpSuboption::Uuid && data.size() >= uuidLenght)
  {
    block.uuid = ToHex(&data[0], 4) + "-" +
                 ToHex(&data[4], 2) + "-" +
                 ToHex(&data[6], 2) + "-" +
                 ToHex(&data[8], 2) + "-" +
                 ToHex(&data[10], 6);
  }
  return block;
}
 
const std::map<std::string, BlockKey>& Params()
{
  static const std::map<std::string, BlockKey> table = {
      {"name", MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::NAME_OF_STATION.first), PNDCPBlock::NAME_OF_STATION.second)},
      {"ip", MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::IP_ADDRESS.first), PNDCPBlock::IP_ADDRESS.second)},
  };
  return table;
}
 
// =============================================================================
// DCPDeviceDescription
// =============================================================================
 
DCPDeviceDescription::DCPDeviceDescription(const MacAddress& macBytes,
                                           const std::map<BlockKey, std::vector<std::uint8_t>>& blocks)
{
  mac = Mac2String(macBytes);
 
  auto get = [&](BlockKey key) -> const std::vector<std::uint8_t>*
  {
    auto it = blocks.find(key);
    return it != blocks.end() ? &it->second : nullptr;
  };
 
  if (const auto* typeBlock = get(MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_TYPE.first), PNDCPBlock::DEVICE_TYPE.second)))
  {
    auto firstNonNull = std::find_if(typeBlock->begin(), typeBlock->end(), [](char c)
    {
      return c != '\0';
    });
    const std::string deviceTypeString(firstNonNull, typeBlock->end());
    this->deviceType = deviceTypeString;
  }
  if (const auto* nameBlock = get(MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::NAME_OF_STATION.first), PNDCPBlock::NAME_OF_STATION.second)))
  {
    auto firstNonNull = std::find_if(nameBlock->begin(), nameBlock->end(), [](char c)
    {
      return c != '\0';
    });
 
    const std::string stationName(firstNonNull, nameBlock->end());
    this->name = stationName;
  }
 
  if (const auto* ipBlock = get(MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::IP_ADDRESS.first), PNDCPBlock::IP_ADDRESS.second)); (ipBlock != nullptr) && ipBlock->size() >= 12)
  {
    if (ipBlock->size() >= 14U) // ipBlockInfo (2) ip (4), netmask (4), gw (4)
    {
      wire::Reader r(*ipBlock);
 
      ipBlockInfo = static_cast<DcpIpBlockInfo>(r.U16());
      ipConflict = HasConflict(ipBlockInfo);
      ipSetByDhcp = IsDhcp(ipBlockInfo);
 
      ip = String2Ip(r.Fixed<4U>());
      netmask = String2Ip(r.Fixed<4U>());
      gateway = String2Ip(r.Fixed<4U>());
    }
    else if (ipBlock->size() >= 12U) // ip (4), netmask (4), gw (4)
    {
      wire::Reader r(*ipBlock);
 
      ip = String2Ip(r.Fixed<4U>());
      netmask = String2Ip(r.Fixed<4U>());
      gateway = String2Ip(r.Fixed<4U>());
    }
  }
 
  if (const auto* devId = get(MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_ID.first), PNDCPBlock::DEVICE_ID.second)); devId && devId->size() >= 4)
  {
    wire::Reader r(*devId);
    r.Skip(devId->size() - 4U);
 
    vendorId = r.U16();
    deviceId = r.U16();
 
    vendorHigh = ByteAt(vendorId, 1U);
    vendorLow = ByteAt(vendorId, 0U);
    deviceHigh = ByteAt(deviceId, 1U);
    deviceLow = ByteAt(deviceId, 0U);
  }
 
  if (const auto* roleBlock = get(MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_ROLE.first), PNDCPBlock::DEVICE_ROLE.second)); roleBlock && !roleBlock->empty())
  {
    wire::Reader r(*roleBlock);
 
    this->deviceRole = r.U8();
    this->deviceRoles = DecodeDeviceRole(this->deviceRole);
  }
 
  if (const auto* inst = get(MakeBlockKey(DcpOption::Device, DcpDeviceSuboption::Instance)); inst && inst->size() >= 2)
  {
    wire::Reader r(*inst);
    deviceInstance = {r.U8(), r.U8()};
  }
 
  if (const auto* alias = get(MakeBlockKey(DcpOption::Device, DcpDeviceSuboption::Alias)))
  {
    aliasName = DecodeBytes(*alias);
  }
 
  if (const auto* opts = get(MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_OPTIONS.first), PNDCPBlock::DEVICE_OPTIONS.second)); opts && opts->size() >= 2)
  {
    wire::Reader r(*opts);
 
    for (std::size_t i = 0; i + 1 < opts->size(); i += sizeof(std::uint16_t))
    {
      const auto option = static_cast<DcpOption>(r.U8());
      const auto suboption = r.U8();
 
      supportedOptions.emplace_back(option, suboption);
    }
  }
 
  for (const auto& [key, Data] : blocks)
  {
    if (key.option == DcpOption::Dhcp)
    {
      dhcpBlocks.push_back(DCPDHCPBlock::Parse(static_cast<DcpDhcpSuboption>(key.suboption), Data));
    }
  }
 
  if (const auto* init = get(MakeBlockKey(DcpOption::DeviceInitiative, DcpDeviceInitiativeSuboption::Initiative));
      (init != nullptr) && init->size() >= 2)
  {
    wire::Reader r(*init);
    deviceInitiative = static_cast<DcpDeviceInitiative>(r.U16());
    issuesHello = deviceInitiative == DcpDeviceInitiative::IssueHello;
  }
 
  static const std::vector<BlockKey> known = {
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::IP_ADDRESS.first), PNDCPBlock::IP_ADDRESS.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_TYPE.first), PNDCPBlock::DEVICE_TYPE.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::NAME_OF_STATION.first), PNDCPBlock::NAME_OF_STATION.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_ID.first), PNDCPBlock::DEVICE_ID.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_ROLE.first), PNDCPBlock::DEVICE_ROLE.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_OPTIONS.first), PNDCPBlock::DEVICE_OPTIONS.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_ALIAS.first), PNDCPBlock::DEVICE_ALIAS.second),
      MakeBlockKey(static_cast<DcpOption>(PNDCPBlock::DEVICE_INSTANCE.first), PNDCPBlock::DEVICE_INSTANCE.second),
      MakeBlockKey(DcpOption::Device, DcpDeviceSuboption::Instance),
      MakeBlockKey(DcpOption::Device, DcpDeviceSuboption::Alias),
      MakeBlockKey(DcpOption::DeviceInitiative, DcpDeviceInitiativeSuboption::Initiative),
  };
  for (const auto& [key, value] : blocks)
  {
    if (key.option == DcpOption::Dhcp)
    {
      continue;
    }
    if (std::ranges::find(known, key) == known.end())
    {
      rawBlocks[key] = value;
    }
  }
}
 
std::string DCPDeviceDescription::VendorName() const
{
  return GetVendorName(VendorId());
}
 
std::string DCPDeviceDescription::ToString() const
{
  std::string out = "PROFINET Device: " + name + "\n";
  out += "  MAC:     " + mac + "\n";
  if (!deviceType.empty())
  {
    out += "  Type:    " + deviceType + "\n";
  }
  out += "  IP:      " + ip + "\n";
  out += "  Netmask: " + netmask + "\n";
  out += "  Gateway: " + gateway + "\n";
  if (ipBlockInfo != DcpIpBlockInfo::NotSet)
  {
    out += "  IP Info: " + GetIPBlockInfoName(ipBlockInfo) + "\n";
  }
  if (ipConflict)
  {
    out += "  Warning: IP address conflict detected\n";
  }
  if (ipSetByDhcp)
  {
    out += "  IP Source: DHCP\n";
  }
  out += "  Vendor:  " + VendorName() + " (" + Hex4(VendorId()) + ")\n";
  out += "  Device:  " + Hex4(DeviceId()) + "\n";
  if (!deviceRoles.empty())
  {
    out += "  Role:    ";
    for (std::size_t i = 0; i < deviceRoles.size(); ++i)
    {
      out += deviceRoles[i];
      if (i + 1 < deviceRoles.size())
      {
        out += ", ";
      }
    }
    out += "\n";
  }
  if (deviceInstance != std::pair<std::uint8_t, std::uint8_t>{0, 0})
  {
    out += "  Instance: " + std::to_string(deviceInstance.first) + "." +
           std::to_string(deviceInstance.second) + "\n";
  }
  if (!aliasName.empty())
  {
    out += "  Alias:   " + aliasName + "\n";
  }
  if (deviceInitiative != DcpDeviceInitiative::NoHello)
  {
    out += "  Initiative: " + GetDeviceInitiativeName(deviceInitiative) + "\n";
  }
  if (!supportedOptions.empty())
  {
    out += "  Supports: ";
    for (std::size_t i = 0; i < supportedOptions.size(); ++i)
    {
      out += GetBlockName(static_cast<DcpOption>(supportedOptions[i].option), supportedOptions[i].suboption);
      if (i + 1 < supportedOptions.size())
      {
        out += ", ";
      }
    }
    out += "\n";
  }
  if (!dhcpBlocks.empty())
  {
    out += "  DHCP:\n";
    for (const auto& b : dhcpBlocks)
    {
      if (b.hostname)
      {
        out += "    Hostname: " + *b.hostname + "\n";
      }
      else if (b.fqdn)
      {
        out += "    FQDN: " + *b.fqdn + "\n";
      }
      else if (b.uuid)
      {
        out += "    UUID: " + *b.uuid + "\n";
      }
      else
      {
        out += "    " + b.suboptionName + ": " + ToHex(b.rawData) + "\n";
      }
    }
  }
  for (const auto& [key, Data] : rawBlocks)
  {
    out += "  Unknown (" +
           std::to_string(static_cast<int>(key.option)) + "," +
           std::to_string(static_cast<int>(key.suboption)) +
           "): " + ToHex(Data) + "\n";
  }
  if (!out.empty() && out.back() == '\n')
  {
    out.pop_back();
  }
  return out;
}
 
// =============================================================================
// Frame builders / parsers (internal helpers)
// =============================================================================
 
namespace
{
 
Bytes BuildEthernetDcp(const MacAddress& dst, const MacAddress& src, const PNDCPHeader& dcp)
{
  EthernetHeader eth;
  eth.dst = dst;
  eth.src = src;
  eth.type = PROFINET_ETHERTYPE;
  eth.payload = dcp.ToBytes();
  return eth.ToBytes();
}
 
bool EqualsIcase(std::string_view lhs, std::string_view rhs)
{
  return std::ranges::equal(lhs, rhs, [](char a, char b)
  {
    return std::tolower(static_cast<unsigned char>(a)) ==
           std::tolower(static_cast<unsigned char>(b));
  });
}
 
} // namespace
 
// =============================================================================
// Public operations
// =============================================================================
Bytes BuildSetParamRequest(const MacAddress& dst,
                           const MacAddress& src,
                           const std::string& param,
                           const std::string& value,
                           bool permanent)
{
  if (EqualsIcase(param, "ip"))
  {
    // The IP suite must be sent as 12 binary bytes(IP + mask + gateway),
    // not an ASCII string; an ASCII value fails the device's length
    // check and is never applied.
    throw DCPError("Use SetIp() to configure the IP address");
  }
  auto it = Params().find(param);
  if (it == Params().end())
  {
    throw DCPError("Unknown parameter: '" + param + "'");
  }
  if (param == "name" && value.size() > DCP_MAX_NAME_LENGTH)
  {
    throw ValidationError("Station name exceeds maximum length: " + std::to_string(value.size()) +
                          " > " + std::to_string(DCP_MAX_NAME_LENGTH));
  }
  const BlockKey key = it->second;
  Bytes valueBytes = ToVec(value);
  const std::uint32_t xid = GenerateXid();
  const std::uint16_t qualifier = permanent ? 0x0001 : 0x0000;
 
  PNDCPBlockRequest block;
  block.option = key.option;
  block.suboption = key.suboption;
  block.length = static_cast<std::uint16_t>(valueBytes.size() + 2);
  wire::PutBigEndian(block.payload, qualifier);
  wire::PutFixed(block.payload, valueBytes);
 
  // const std::uint16_t padding = valueBytes.size() % 2 == 1 ? 1 : 0;
 
  auto blockData = block.ToBytes();
  if (valueBytes.size() % 2 == 1)
  {
    blockData.push_back(0x00);
  }
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;
  dcp.serviceId = DcpServiceId::Set;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(blockData.size());
  dcp.payload = blockData;
  return BuildEthernetDcp(dst, src, dcp);
}
 
Bytes BuildDcpSignalRequest(const MacAddress& dst, const MacAddress& src)
{
  const std::uint32_t xid = GenerateXid();
 
  /*
  const int durationUnits = std::max(1, durationMs / 100);
  const Bytes blockData = {0x00, 0x01, static_cast<std::uint8_t>((durationUnits >> OneOctetShift) & LowByteMask),
                           static_cast<std::uint8_t>(durationUnits & LowByteMask)};
*/
  // Signal block data: BlockQualifier 0x0000 + SignalValue 0x0100
  // ("flash once") - the only value defined by IEC 61158-6-10
  const Bytes blockData = {0x00, 0x00, 0x01, 0x00};
  PNDCPBlockRequest block;
  block.option = DcpOption::Control;
  block.suboption = static_cast<std::uint8_t>(DcpControlSuboption::Signal);
  block.length = static_cast<std::uint16_t>(blockData.size());
  block.payload = blockData;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;
  dcp.serviceId = DcpServiceId::Set;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(blockData.size() + 4);
  dcp.payload = block.ToBytes();
  return BuildEthernetDcp(
      dst,
      src,
      dcp);
}
/*
Bytes BuildSignalRequest(
    const MacAddress& dst,
    const MacAddress& src)
{
  constexpr Bytes signalBlockData{
      0x00,
      0x00,
      0x01,
      0x00};
 
  const std::uint32_t xid = GenerateXid();
 
  PNDCPBlockRequest block;
  block.option = DcpOption::Control;//DCP_OPTION_CONTROL;
  block.suboption = DcpControlSuboption::Signal;//DCP_SUBOPTION_CONTROL_SIGNAL;
  block.length =
      static_cast<std::uint16_t>(
          signalBlockData.size());
  block.payload = signalBlockData;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;//DCP_GET_SET_FRAME_ID;
  dcp.serviceId = DcpServiceId::Set;//PNDCPHeader::SET;
  dcp.serviceType = DcpServiceType::Request;// PNDCPHeader::REQUEST;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length =
      static_cast<std::uint16_t>(
          signalBlockData.size() + 4U);
  dcp.payload = block.ToBytes();
 
  return BuildEthernetDcp(
      dst,
      src,
      dcp);
}*/
std::optional<Bytes> GetParam(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
                              const std::string& param, int timeoutSec)
{
  auto it = Params().find(param);
  if (it == Params().end())
  {
    throw DCPError("Unknown parameter: '" + param + "'");
  }
 
  const MacAddress dst = String2Mac(target);
  const BlockKey key = it->second;
  const std::uint32_t xid = GenerateXid();
 
  PNDCPBlockRequest block;
  block.option = key.option;
  block.suboption = key.suboption;
  block.length = 0;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;
  dcp.serviceId = DcpServiceId::Get;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0;
  // A DCP GET request does NOT contain a normal DCP block header
 
  // For a GET request, the data after the DCP header is a selector:
 
  // Option      1 byte
  // SubOption   1 byte
  // ------------------
  //             2 bytes
  // DCPDataLength = 2
  // Wireshark confirms this directly. In its DCP PDU dissector, after reading DCPDataLength, it specifically handles:
  // GET + REQUEST
  //     -> dissect_PNDCP_Option()
  // rather than dissect_PNDCP_Block(). That function reads exactly:
  // Option      1 byte
  // SubOption   1 byte
  // so the GET request consumes 2 bytes.
  // https://github.com/boundary/wireshark/blob/master/plugins/profinet/packet-pn-dcp.c
 
  dcp.length = 2; // Length of expected parameter to read not: (sizeof(std::uint8_t) * 2) + sizeof(std::uint16_t); // option + suboption + length
 
  // BUT The IEC 61158-6-10 material I found defines:
  // DCPDataLength = total length of the data following the DCP-UC header
  // so 4 instead of 2..
 
  //
  dcp.payload = block.ToBytes(); // euh Need to check with spec..
  // For Get don't use PNDCPBlockRequest, just a 2 byte Get selector, don't add the 2 bytes for length.
  // dcp.payload = {
  //     static_cast<std::uint8_t>(key.option),
  //     key.suboption};
 
  sock.Send(BuildEthernetDcp(dst, src, dcp));
 
  const auto responses = ReadResponse(sock, src, timeoutSec, /*once=*/true, xid);
  std::fprintf(stderr,
               "GetParam: xid=%08x responses=%zu\n",
               xid,
               responses.size());
  for (const auto& [mac, blocks] : responses)
  {
    std::fprintf(stderr,
                 "  response src=%02x:%02x:%02x:%02x:%02x:%02x blocks=%zu\n",
                 mac[0], mac[1], mac[2],
                 mac[3], mac[4], mac[5],
                 blocks.size());
 
    for (const auto& [blockKey, value] : blocks)
    {
      std::fprintf(stderr,
                   "    block option=%02x suboption=%02x size=%zu\n",
                   static_cast<unsigned>(blockKey.option),
                   static_cast<unsigned>(blockKey.suboption),
                   value.size());
    }
  }
  if (!responses.empty())
  {
    const auto& blocks = responses.begin()->second;
    auto bit = blocks.find(key);
    if (bit != blocks.end())
    {
      return bit->second;
    }
  }
  return std::nullopt;
}
 
bool SetParam(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
              const std::string& param, const std::string& value, int timeoutSec, bool permanent, int threadSleepMs)
{
  const MacAddress dst = String2Mac(target);
 
  const Bytes frame = BuildSetParamRequest(dst, src, param, value, permanent);
  sock.Send(frame);
 
  try
  {
    const auto blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DcpBlockError::Ok)
    {
      throw DCPError("DCP SET failed for '" + param + "': " + GetDcpBlockErrorDescription(blockError));
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(threadSleepMs));
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
bool SetIp(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target, const std::string& ip,
           const std::string& netmask, const std::string& gateway, bool permanent, int timeoutSec, int threadSleepMs)
{
  const MacAddress dst = String2Mac(target);
  const std::uint32_t xid = GenerateXid();
 
  auto ipBytes = Ip2String(ip);
  auto netmaskBytes = Ip2String(netmask);
  auto gatewayBytes = Ip2String(gateway);
 
  Bytes valueBytes;
  valueBytes.insert(valueBytes.end(), ipBytes.begin(), ipBytes.end());
  valueBytes.insert(valueBytes.end(), netmaskBytes.begin(), netmaskBytes.end());
  valueBytes.insert(valueBytes.end(), gatewayBytes.begin(), gatewayBytes.end());
 
  const DcpBlockQualifier qualifier = permanent ? DcpBlockQualifier::Permanent : DcpBlockQualifier::Temporary;
 
  PNDCPBlockRequest block;
  block.option = static_cast<DcpOption>(PNDCPBlock::IP_ADDRESS.first);
  block.suboption = PNDCPBlock::IP_ADDRESS.second;
  block.length = static_cast<std::uint16_t>(valueBytes.size() + 2);
  wire::PutBigEndian(block.payload, static_cast<std::uint16_t>(qualifier));
  wire::PutFixed(block.payload, valueBytes);
 
  const std::uint16_t padding = valueBytes.size() % 2 == 0 ? 0 : 1;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;
  dcp.serviceId = DcpServiceId::Set;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(valueBytes.size() + macAddressLength + padding);
  dcp.payload = block.ToBytes();
 
  sock.Send(BuildEthernetDcp(dst, src, dcp));
 
  try
  {
    const auto blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DcpBlockError::Ok)
    {
      throw DCPError("DCP SET IP failed: " + GetDcpBlockErrorDescription(blockError));
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(threadSleepMs));
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
void SendDiscover(IRawEthernetSocket& sock, const MacAddress& src, std::uint16_t responseDelay)
{
  const std::uint32_t xid = GenerateXid();
 
  PNDCPBlockRequest block;
  block.option = DcpOption::All;
  block.suboption = 0xFF;
  block.length = 0;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::IdentifyRequest;
  dcp.serviceId = DcpServiceId::Identify;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = responseDelay;
  const Bytes blockBytes = block.ToBytes();
  dcp.length = static_cast<std::uint16_t>(blockBytes.size());
  dcp.payload = blockBytes;
 
  sock.Send(BuildEthernetDcp(String2Mac(DCP_MULTICAST_MAC), src, dcp));
}
 
void SendRequest(IRawEthernetSocket& sock, const MacAddress& src, BlockKey blockType, const Bytes& value)
{
  const std::uint32_t xid = GenerateXid();
 
  PNDCPBlockRequest block;
  block.option = blockType.option;
  block.suboption = blockType.suboption;
  block.length = static_cast<std::uint16_t>(value.size());
  block.payload = value;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::IdentifyRequest;
  dcp.serviceId = DcpServiceId::Identify;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0x0080;
  const Bytes blockBytes = block.ToBytes();
  dcp.length = static_cast<std::uint16_t>(blockBytes.size());
  dcp.payload = blockBytes;
 
  sock.Send(BuildEthernetDcp(String2Mac(DCP_MULTICAST_MAC), src, dcp));
}
 
ResponseMap ReadResponse(IRawEthernetSocket& sock, const MacAddress& myMac, double timeoutSec, bool once,
                         std::optional<std::uint32_t> expectedXid)
{
  ResponseMap result;
  sock.SetTimeout(std::chrono::milliseconds(2000));
  const MaxTimeout timer{std::chrono::duration<double>(timeoutSec)};
 
  while (!timer.TimedOut())
  {
    const Bytes data = sock.Recv();
    std::fprintf(stderr,
                 "ReadResponse: received %zu bytes, expectedXid=%08x\n",
                 data.size(),
                 expectedXid.value_or(0U));
    if (data.empty())
    {
      if (once)
      {
        break;
      }
      continue;
    }
 
    if (data.size() < 14)
    {
      continue;
    }
 
    EthernetHeader eth;
    try
    {
      eth = EthernetHeader::Parse(data);
      std::fprintf(stderr,
                   "ReadResponse: eth dst=%02x:%02x:%02x:%02x:%02x:%02x "
                   "src=%02x:%02x:%02x:%02x:%02x:%02x type=%04x\n",
                   eth.dst[0], eth.dst[1], eth.dst[2],
                   eth.dst[3], eth.dst[4], eth.dst[5],
                   eth.src[0], eth.src[1], eth.src[2],
                   eth.src[3], eth.src[4], eth.src[5],
                   eth.type);
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    if (eth.dst != myMac)
    {
      std::fprintf(stderr, "ReadResponse: rejected: destination mismatch\n");
      continue;
    }
 
    Bytes payload = eth.payload;
    wire::Reader r(payload);
    if (eth.type == VLAN_ETHERTYPE)
    {
      if (payload.size() < 2 * sizeof(std::uint16_t))
      {
        continue;
      }
      r.Skip(sizeof(std::uint16_t));
      const auto innerType = r.U16();
      if (innerType != PROFINET_ETHERTYPE)
      {
        continue;
      }
      payload = Bytes(payload.begin() + 4, payload.end());
    }
    else if (eth.type != PROFINET_ETHERTYPE)
    {
      continue;
    }
 
    PNDCPHeader dcp;
    try
    {
      dcp = PNDCPHeader::Parse(payload);
      std::fprintf(stderr,
                   "ReadResponse: dcp serviceType=%02x xid=%08x length=%u payload=%zu\n",
                   static_cast<unsigned>(dcp.serviceType),
                   dcp.xId,
                   dcp.length,
                   dcp.payload.size());
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    if (dcp.serviceType != DcpServiceType::ResponseSuccess)
    {
      std::fprintf(stderr, "ReadResponse: rejected: not ResponseSuccess\n");
      continue;
    }
    if (expectedXid && dcp.xId != *expectedXid)
    {
      std::fprintf(stderr,
                   "ReadResponse: rejected: XID mismatch, expected=%08x actual=%08x\n",
                   *expectedXid,
                   dcp.xId);
      continue;
    }
 
    std::map<BlockKey, Bytes> parsed;
    // dcp.length includes the whole block-list; each block ends 2-byte aligned.
    const std::size_t consumedLimit = dcp.length > 6 ? static_cast<std::size_t>(dcp.length) : 0;
    const Bytes blocksRegion = dcp.payload.size() > consumedLimit
                                   ? Bytes(dcp.payload.begin(), dcp.payload.begin() + consumedLimit)
                                   : dcp.payload;
    ForEachBlock(blocksRegion, [&](DcpOption option, std::uint8_t suboption, const Bytes& blockPayload)
    {
      parsed[MakeBlockKey(option, suboption)] = blockPayload;
    });
 
    result[eth.src] = std::move(parsed);
    if (once)
    {
      break;
    }
  }
 
  return result;
}
 
void SendHello(IRawEthernetSocket& sock, const MacAddress& src, const std::string& stationName,
               const std::string& ip, const std::string& netmask, const std::string& gateway,
               std::pair<std::uint16_t, std::uint16_t> deviceId, DcpDeviceRole deviceRole)
{
  const std::uint32_t xid = GenerateXid();
  Bytes blocksData;
 
  // Name of Station block
  const Bytes nameBytes = ToVec(stationName);
  PNDCPBlockRequest nameBlock;
  nameBlock.option = DcpOption::Device;
  nameBlock.suboption = static_cast<std::uint8_t>(DcpDeviceSuboption::Name);
  nameBlock.length = static_cast<std::uint16_t>(nameBytes.size());
  nameBlock.payload = nameBytes;
  Bytes nameBlockBytes = nameBlock.ToBytes();
  blocksData.insert(blocksData.end(), nameBlockBytes.begin(), nameBlockBytes.end());
  if (nameBytes.size() % 2 == 1)
  {
    blocksData.push_back(0x00);
  }
 
  // IP block
  auto ipB = Ip2String(ip);
  auto nmB = Ip2String(netmask);
  auto gwB = Ip2String(gateway);
  Bytes ipPayload;
  ipPayload.insert(ipPayload.end(), ipB.begin(), ipB.end());
  ipPayload.insert(ipPayload.end(), nmB.begin(), nmB.end());
  ipPayload.insert(ipPayload.end(), gwB.begin(), gwB.end());
  PNDCPBlockRequest ipBlock;
  ipBlock.option = DcpOption::Ip;
  ipBlock.suboption = static_cast<std::uint8_t>(DcpIpSuboption::IpParameter);
  ipBlock.length = static_cast<std::uint16_t>(ipPayload.size());
  ipBlock.payload = ipPayload;
 
  Bytes ipBlockBytes = ipBlock.ToBytes();
  wire::PutFixed(blocksData, ipBlockBytes);
 
  // Device ID block
  Bytes deviceIdBytes;
  deviceIdBytes.reserve(4U);
  wire::PutBigEndian(deviceIdBytes, deviceId.first);
  wire::PutBigEndian(deviceIdBytes, deviceId.second);
 
  PNDCPBlockRequest deviceIdBlock;
  deviceIdBlock.option = DcpOption::Device;
  deviceIdBlock.suboption = static_cast<std::uint8_t>(DcpDeviceSuboption::DeviceId);
  deviceIdBlock.length = static_cast<std::uint16_t>(deviceIdBytes.size());
  deviceIdBlock.payload = deviceIdBytes;
  Bytes deviceIdBlockBytes = deviceIdBlock.ToBytes();
  wire::PutFixed(blocksData, deviceIdBlockBytes);
 
  // Device Role block
  PNDCPBlockRequest roleBlock;
  roleBlock.option = DcpOption::Device;
  roleBlock.suboption = static_cast<std::uint8_t>(DcpDeviceSuboption::Role);
  roleBlock.length = 2;
  roleBlock.payload = {static_cast<std::uint8_t>(deviceRole), 0x00};
  Bytes roleBlockBytes = roleBlock.ToBytes();
  blocksData.insert(blocksData.end(), roleBlockBytes.begin(), roleBlockBytes.end());
 
  // Device Initiative block
  PNDCPBlockRequest initBlock;
  initBlock.option = DcpOption::DeviceInitiative;
  initBlock.suboption = static_cast<std::uint8_t>(DcpDeviceInitiativeSuboption::Initiative);
  initBlock.length = 2;
  initBlock.payload = {0x00, static_cast<std::uint8_t>(DcpDeviceInitiative::IssueHello)};
  Bytes initBlockBytes = initBlock.ToBytes();
  blocksData.insert(blocksData.end(), initBlockBytes.begin(), initBlockBytes.end());
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::Hello;
  dcp.serviceId = DcpServiceId::Hello;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(blocksData.size());
  dcp.payload = blocksData;
 
  sock.Send(BuildEthernetDcp(String2Mac(DCP_HELLO_MULTICAST_MAC), src, dcp));
}
 
std::vector<DCPDeviceDescription> ReceiveHello(IRawEthernetSocket& sock, const MacAddress& /*myMac*/,
                                               double timeoutSec,
                                               const std::function<void(const DCPDeviceDescription&)>& callback)
{
  std::vector<DCPDeviceDescription> devices;
  sock.SetTimeout(std::chrono::milliseconds(2000));
  const MaxTimeout timer{std::chrono::duration<double>(timeoutSec)};
 
  while (!timer.TimedOut())
  {
    const Bytes data = sock.Recv();
    if (data.empty() || data.size() < 14)
    {
      continue;
    }
 
    EthernetHeader eth;
    try
    {
      eth = EthernetHeader::Parse(data);
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    Bytes payload = eth.payload;
    wire::Reader r(payload);
    if (eth.type == VLAN_ETHERTYPE)
    {
      if (payload.size() < 2 * sizeof(std::uint16_t))
      {
        continue;
      }
      r.Skip(sizeof(std::uint16_t));
      const auto innerType = r.U16();
      if (innerType != PROFINET_ETHERTYPE)
      {
        continue;
      }
      payload = Bytes(payload.begin() + (2 * sizeof(std::uint16_t)), payload.end());
    }
    else if (eth.type != PROFINET_ETHERTYPE)
    {
      continue;
    }
    if (payload.size() < 10)
    {
      continue;
    }
 
    PNDCPHeader dcp;
    try
    {
      dcp = PNDCPHeader::Parse(payload);
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    if (dcp.serviceId != DcpServiceId::Hello)
    {
      continue;
    }
    if (dcp.serviceType != DcpServiceType::Request)
    {
      continue;
    }
 
    std::map<BlockKey, Bytes> blocks;
    ForEachBlock(dcp.payload, [&](DcpOption option, std::uint8_t suboption, const Bytes& blockPayload)
    {
      blocks[MakeBlockKey(option, suboption)] = blockPayload;
    });
 
    try
    {
      const DCPDeviceDescription device(eth.src, blocks);
      devices.push_back(device);
      if (callback)
      {
        callback(device);
      }
    }
    // NOLINTNEXTLINE(bugprone-empty-catch)
    catch (const std::exception&)
    {
      // Ignore malformed Hello PDUs.
    }
  }
 
  return devices;
}
 
bool SignalDevice(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
                  [[maybe_unused]] int durationMs, double timeoutSec)
{
  const MacAddress dst = String2Mac(target);
  const Bytes frame = BuildDcpSignalRequest(dst, src);
  sock.Send(frame);
 
  try
  {
    const auto blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DcpBlockError::Ok)
    {
      throw DCPError("DCP Signal failed: " + GetDcpBlockErrorDescription(blockError));
    }
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
bool ResetToFactory(IRawEthernetSocket& sock, const MacAddress& src, const std::string& target,
                    DcpResetMode mode, double timeoutSec)
{
  const MacAddress dst = String2Mac(target);
  const std::uint32_t xid = GenerateXid();
 
  const auto modeValue = static_cast<std::uint16_t>(mode);
 
  Bytes blockQualifier;
  wire::PutBigEndian(blockQualifier, modeValue);
 
  PNDCPBlockRequest block;
  block.option = DcpOption::Control;
  block.suboption = static_cast<std::uint8_t>(DcpControlSuboption::ResetToFactory);
  block.length = static_cast<std::uint16_t>(blockQualifier.size());
  block.payload = blockQualifier;
 
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;
  dcp.serviceId = DcpServiceId::Set;
  dcp.serviceType = DcpServiceType::Request;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(blockQualifier.size() + 4);
  dcp.payload = block.ToBytes();
 
  sock.Send(BuildEthernetDcp(dst, src, dcp));
 
  try
  {
    const auto blockError =
        RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DcpBlockError::Ok)
    {
      throw DCPError("DCP Reset to Factory failed: " + GetDcpBlockErrorDescription(blockError));
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
} // namespace profinet::dcp