dcp.cpp

Go to the documentation of this file.

 
 
#include "profinet/dcp.h"
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#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));
}
 
// name -> (option, suboption)
const std::map<std::uint8_t, std::string>& OptionNames()
{
  static const std::map<std::uint8_t, std::string> table = {
      {0x01, "IP"},
      {0x02, "Device"},
      {0x03, "DHCP"},
      {0x04, "Reserved"},
      {0x05, "Control"},
      {0x06, "DeviceInitiative"},
      {0x07, "NME"},
      {0xFF, "All"},
  };
  return table;
}
 
const std::map<std::uint8_t, std::map<std::uint8_t, std::string>>& SuboptionNames()
{
  static const std::map<std::uint8_t, std::map<std::uint8_t, std::string>> table = {
      {0x01, {{0x01, "MAC"}, {0x02, "IP"}, {0x03, "FullIPSuite"}}},
      {0x02,
       {{0x01, "Type"}, {0x02, "Name"}, {0x03, "DeviceID"}, {0x04, "Role"}, {0x05, "Options"}, {0x06, "Alias"}, {0x07, "Instance"}, {0x08, "OEM-ID"}, {0x0A, "RSI"}}},
      {0x03,
       {{0x0C, "Hostname"}, {0x2B, "VendorSpec"}, {0x36, "ServerID"}, {0x37, "ParamReq"}, {0x3C, "ClassID"}, {0x3D, "ClientID"}, {0x51, "FQDN"}, {0x61, "UUID"}, {0xFF, "Control"}}},
      {0x05,
       {{0x01, "Start"}, {0x02, "Stop"}, {0x03, "Signal"}, {0x04, "Response"}, {0x05, "FactoryReset"}, {0x06, "ResetToFactory"}}},
      {0x06, {{0x01, "Initiative"}}},
  };
  return table;
}
 
const std::map<std::uint16_t, std::string>& DeviceRoleNames()
{
  static const std::map<std::uint16_t, std::string> table = {
      {DEVICE_ROLE_IO_DEVICE, "IO-Device"},
      {DEVICE_ROLE_IO_CONTROLLER, "IO-Controller"},
      {DEVICE_ROLE_IO_MULTIDEVICE, "IO-Multidevice"},
      {DEVICE_ROLE_PN_SUPERVISOR, "PN-Supervisor"},
  };
  return table;
}
 
const std::map<std::uint8_t, std::string>& DcpBlockErrorNames()
{
  static const std::map<std::uint8_t, std::string> table = {
      {DCP_BLOCK_ERROR_OK, "OK"},
      {DCP_BLOCK_ERROR_OPTION_UNSUPPORTED, "Option not supported"},
      {DCP_BLOCK_ERROR_SUBOPTION_UNSUPPORTED, "Suboption not supported or no dataset available"},
      {DCP_BLOCK_ERROR_SUBOPTION_NOT_SET, "Suboption not set"},
      {DCP_BLOCK_ERROR_RESOURCE, "Resource error"},
      {DCP_BLOCK_ERROR_SET_NOT_POSSIBLE, "SET not possible by local reasons"},
      {DCP_BLOCK_ERROR_IN_OPERATION, "In operation, SET not possible"},
  };
  return table;
}
 
template <typename Fn>
void ForEachBlock(const std::vector<std::uint8_t>& data, Fn&& fn)
{
  std::size_t offset = 0;
  while (offset + 4 <= data.size())
  {
    const std::uint8_t option = data[offset];
    const std::uint8_t suboption = data[offset + 1];
    const auto length = static_cast<std::uint16_t>((data[offset + 2] << OneOctetShift) | data[offset + 3]);
    const std::size_t payloadStart = offset + 4;
    const std::size_t payloadEnd = std::min(payloadStart + length, data.size());
    const std::vector<std::uint8_t> payload(data.begin() + payloadStart, data.begin() + payloadEnd);
 
    fn(option, suboption, payload);
 
    std::size_t blockLen = 4 + length;
    if (length % 2 == 1)
    {
      blockLen += 1;
    }
    if (blockLen == 0)
    {
      break;
    }
    offset += blockLen;
  }
}
 
} // namespace
 
std::vector<std::string> DecodeDeviceRole(std::uint8_t roleByte)
{
  std::vector<std::string> roles;
  for (const auto& [mask, Name] : DeviceRoleNames())
  {
    if ((roleByte & mask) != 0)
    {
      roles.push_back(Name);
    }
  }
  if (roles.empty())
  {
    roles.emplace_back("Unknown");
  }
  return roles;
}
 
std::string GetBlockName(std::uint8_t option, std::uint8_t suboption)
{
  std::string optName;
  auto oit = OptionNames().find(option);
  if (oit != OptionNames().end())
  {
    optName = oit->second;
  }
  else if (option >= 0x80 && option <= 0xFE)
  {
    optName = "Vendor-" + Hex2(option);
  }
  else
  {
    optName = "Opt-" + Hex2(option);
  }
 
  std::string suboptName = Hex2(suboption);
  auto sit = SuboptionNames().find(option);
  if (sit != SuboptionNames().end())
  {
    auto ssit = sit->second.find(suboption);
    if (ssit != sit->second.end())
    {
      suboptName = ssit->second;
    }
  }
 
  return optName + "/" + suboptName;
}
 
std::uint8_t RecvSetResponse(const 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() < 4)
      {
        continue;
      }
      const auto innerType = static_cast<std::uint16_t>((payload[2] << OneOctetShift) | payload[3]);
      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");
}
 
std::uint8_t 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() < 4)
    {
      throw DCPError("VLAN frame too short");
    }
    const auto innerType = static_cast<std::uint16_t>((payload[2] << OneOctetShift) | payload[3]);
    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 == DCP_SERVICE_TYPE_RESPONSE_UNSUPPORTED)
  {
    throw DCPError("DCP SET: service not supported by device");
  }
  if (hdr.serviceType != DCP_SERVICE_TYPE_RESPONSE_SUCCESS)
  {
    throw DCPError("DCP SET: unexpected service_type " + Hex2(hdr.serviceType));
  }
 
  std::uint8_t result = DCP_BLOCK_ERROR_OK;
  bool found = false;
  ForEachBlock(hdr.payload, [&](std::uint8_t option, std::uint8_t suboption, const Bytes& blockPayload)
  {
    if (found)
    {
      return;
    }
    if (option == DCP_OPTION_CONTROL && suboption == DCP_SUBOPTION_CONTROL_RESPONSE)
    {
      found = true;
      if (blockPayload.size() >= 3)
      {
        result = blockPayload[2];
      }
      else if (!blockPayload.empty())
      {
        result = blockPayload[0];
      }
    }
  });
  // No Control/Response block found - some devices omit it; treat as success.
  return result;
}
 
std::string IPBlockInfo::GetName(std::uint16_t info)
{
  switch (info)
  {
    case IP_NOT_SET:
      return "IP not set";
    case IP_SET:
      return "IP set";
    case IP_SET_BY_DHCP:
      return "IP set by DHCP";
    case IP_NOT_SET_CONFLICT:
      return "IP not set (address conflict detected)";
    case IP_SET_CONFLICT:
      return "IP set (address conflict detected)";
    case IP_SET_BY_DHCP_CONFLICT:
      return "IP set by DHCP (address conflict detected)";
    default:
      return "Unknown (" + Hex4(info) + ")";
  }
}
 
std::string BlockQualifier::GetName(std::uint16_t qualifier)
{
  return qualifier == PERMANENT ? "Permanent" : (qualifier == TEMPORARY ? "Temporary" : "Unknown (" + Hex4(qualifier) + ")");
}
 
std::string ResetQualifier::GetName(std::uint16_t qualifier)
{
  switch (qualifier)
  {
    case 0x0002:
    case 0x0003:
      return "Reset application data";
    case 0x0004:
    case 0x0005:
      return "Reset communication parameter";
    case 0x0006:
    case 0x0007:
      return "Reset engineering parameter";
    case 0x0008:
    case 0x0009:
      return "Reset all stored data";
    case 0x000A:
    case 0x000B:
      return "Reset engineering parameter";
    case 0x0010:
    case 0x0011:
      return "Reset to factory values";
    case 0x0012:
    case 0x0013:
      return "Reset and restore data";
    default:
      return "Unknown (" + Hex4(qualifier) + ")";
  }
}
 
std::string DeviceInitiative::GetName(std::uint16_t value)
{
  if (value == NO_HELLO)
  {
    return "Device does not issue DCP-Hello after power on";
  }
  if (value == ISSUE_HELLO)
  {
    return "Device issues DCP-Hello after power on";
  }
  return "Unknown (" + Hex4(value) + ")";
}
 
std::string DCPResponseCode::GetName(std::uint8_t code)
{
  switch (code)
  {
    case NO_ERROR:
      return "No error";
    case OPTION_NOT_SUPPORTED:
      return "Option not supported";
    case SUBOPTION_NOT_SUPPORTED:
      return "Suboption not supported or no DataSet available";
    case SUBOPTION_NOT_SET:
      return "Suboption not set";
    case RESOURCE_ERROR:
      return "Resource error";
    case SET_NOT_POSSIBLE:
      return "Set not possible";
    case IN_OPERATION_SET_NOT_POSSIBLE:
      return "In operation, SET not possible";
    default:
      return "Unknown (" + Hex2(code) + ")";
  }
}
 
std::string DcpBlockErrorName(std::uint8_t code)
{
  auto it = DcpBlockErrorNames().find(code);
  if (it != DcpBlockErrorNames().end())
  {
    return it->second;
  }
  return "Unknown error (" + Hex2(code) + ")";
}
 
DCPDHCPBlock DCPDHCPBlock::Parse(std::uint8_t suboption, const std::vector<std::uint8_t>& data)
{
  DCPDHCPBlock block;
  block.suboption = suboption;
  auto sit = SuboptionNames().find(DCP_OPTION_DHCP);
  if (sit != SuboptionNames().end())
  {
    auto ssit = sit->second.find(suboption);
    block.suboptionName = ssit != sit->second.end() ? ssit->second : Hex2(suboption);
  }
  else
  {
    block.suboptionName = Hex2(suboption);
  }
  block.rawData = data;
 
  if (suboption == DCP_SUBOPTION_DHCP_HOSTNAME)
  {
    block.hostname = DecodeBytes(data);
  }
  else if (suboption == DCP_SUBOPTION_DHCP_CLIENT_ID)
  {
    block.clientId = data;
  }
  else if (suboption == DCP_SUBOPTION_DHCP_VENDOR_SPEC)
  {
    block.vendorSpecific = data;
  }
  else if (suboption == DCP_SUBOPTION_DHCP_FQDN)
  {
    block.fqdn = DecodeBytes(data);
  }
  else if (suboption == DCP_SUBOPTION_DHCP_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", PNDCPBlock::NAME_OF_STATION},
      {"ip", PNDCPBlock::IP_ADDRESS},
  };
  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(PNDCPBlock::DEVICE_TYPE))
  {
    // DeviceType = DecodeBytes(*type_block);
    // Zoek de eerste byte die NIET '\0' is
    auto firstNonNull = std::find_if(typeBlock->begin(), typeBlock->end(), [](char c)
    {
      return c != '\0';
    });
 
    // Maak de string vanaf dat punt tot het einde
    const std::string deviceTypeString(firstNonNull, typeBlock->end());
    this->deviceType = deviceTypeString;
  }
  if (const auto* nameBlock = get(PNDCPBlock::NAME_OF_STATION))
  {
    // Name = std::string(name_block->begin(), name_block->end());
 
    // Zoek de eerste byte die NIET '\0' is
    auto firstNonNull = std::find_if(nameBlock->begin(), nameBlock->end(), [](char c)
    {
      return c != '\0';
    });
 
    // Maak de string vanaf dat punt tot het einde
    const std::string name(firstNonNull, nameBlock->end());
    this->name = name;
  }
 
  if (const auto* ipBlock = get(PNDCPBlock::IP_ADDRESS); (ipBlock != nullptr) && ipBlock->size() >= 12)
  {
    ip = String2Ip(&(*ipBlock)[0], 4);
    netmask = String2Ip(&(*ipBlock)[4], 4);
    gateway = String2Ip(&(*ipBlock)[8], 4);
    if (ipBlock->size() >= 14)
    {
      ipBlockInfo = static_cast<std::uint16_t>(((*ipBlock)[0] << OneOctetShift) | (*ipBlock)[1]);
      ipConflict = IPBlockInfo::HasConflict(ipBlockInfo);
      ipSetByDhcp = IPBlockInfo::IsDhcp(ipBlockInfo);
      ip = String2Ip(&(*ipBlock)[2], 4);
      netmask = String2Ip(&(*ipBlock)[6], 4);
      gateway = String2Ip(&(*ipBlock)[10], 4);
    }
  }
 
  if (const auto* devId = get(PNDCPBlock::DEVICE_ID); devId && devId->size() >= 4)
  {
    vendorHigh = (*devId)[devId->size() - 4];
    vendorLow = (*devId)[devId->size() - 3];
    deviceHigh = (*devId)[devId->size() - 2];
    deviceLow = (*devId)[devId->size() - 1];
  }
 
  if (const auto* roleBlock = get(PNDCPBlock::DEVICE_ROLE); roleBlock && !roleBlock->empty())
  {
    this->deviceRole = (*roleBlock)[0];
    this->deviceRoles = DecodeDeviceRole(this->deviceRole);
  }
 
  if (const auto* inst = get({DCP_OPTION_DEVICE, DCP_SUBOPTION_DEVICE_INSTANCE}); inst && inst->size() >= 2)
  {
    deviceInstance = {(*inst)[0], (*inst)[1]};
  }
 
  if (const auto* alias = get({DCP_OPTION_DEVICE, DCP_SUBOPTION_DEVICE_ALIAS}))
  {
    aliasName = DecodeBytes(*alias);
  }
 
  if (const auto* opts = get(PNDCPBlock::DEVICE_OPTIONS); opts && opts->size() >= 2)
  {
    for (std::size_t i = 0; i + 1 < opts->size(); i += 2)
    {
      supportedOptions.emplace_back((*opts)[i], (*opts)[i + 1]);
    }
  }
 
  for (const auto& [key, Data] : blocks)
  {
    if (key.first == DCP_OPTION_DHCP)
    {
      dhcpBlocks.push_back(DCPDHCPBlock::Parse(key.second, Data));
    }
  }
 
  if (const auto* init = get({DCP_OPTION_DEVICE_INITIATIVE, DCP_SUBOPTION_DEVICE_INITIATIVE});
      init && init->size() >= 2)
  {
    deviceInitiative = static_cast<std::uint16_t>(((*init)[0] << OneOctetShift) | (*init)[1]);
    issuesHello = deviceInitiative == DeviceInitiative::ISSUE_HELLO;
  }
 
  static const std::vector<BlockKey> known = {
      PNDCPBlock::IP_ADDRESS,
      PNDCPBlock::DEVICE_TYPE,
      PNDCPBlock::NAME_OF_STATION,
      PNDCPBlock::DEVICE_ID,
      PNDCPBlock::DEVICE_ROLE,
      PNDCPBlock::DEVICE_OPTIONS,
      PNDCPBlock::DEVICE_ALIAS,
      PNDCPBlock::DEVICE_INSTANCE,
      {DCP_OPTION_DEVICE, DCP_SUBOPTION_DEVICE_INSTANCE},
      {DCP_OPTION_DEVICE, DCP_SUBOPTION_DEVICE_ALIAS},
      {DCP_OPTION_DEVICE_INITIATIVE, DCP_SUBOPTION_DEVICE_INITIATIVE},
  };
  for (const auto& [key, value] : blocks)
  {
    if (key.first == DCP_OPTION_DHCP)
    {
      continue;
    }
    if (std::find(known.begin(), known.end(), 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 != 0u)
  {
    out += "  IP Info: " + IPBlockInfo::GetName(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 != 0u)
  {
    out += "  Initiative: " + DeviceInitiative::GetName(deviceInitiative) + "\n";
  }
  if (!supportedOptions.empty())
  {
    out += "  Supports: ";
    for (std::size_t i = 0; i < supportedOptions.size(); ++i)
    {
      out += GetBlockName(supportedOptions[i].first, supportedOptions[i].second);
      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(key.first) + "," + std::to_string(key.second) +
           "): " + 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.first;
  block.suboption = key.second;
  block.length = static_cast<std::uint16_t>(valueBytes.size() + 2);
  block.payload = {static_cast<std::uint8_t>((qualifier >> OneOctetShift) & LowByteMask),
                   static_cast<std::uint8_t>(qualifier & LowByteMask)};
  block.payload.insert(block.payload.end(), valueBytes.begin(), valueBytes.end());
 
  // 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 = DCP_GET_SET_FRAME_ID;
  dcp.serviceId = PNDCPHeader::SET;
  dcp.serviceType = PNDCPHeader::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 = DCP_OPTION_CONTROL;
  block.suboption = DCP_SUBOPTION_CONTROL_SIGNAL;
  block.length = static_cast<std::uint16_t>(blockData.size());
  block.payload = blockData;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_GET_SET_FRAME_ID;
  dcp.serviceId = PNDCPHeader::SET;
  dcp.serviceType = PNDCPHeader::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 = DCP_OPTION_CONTROL;
  block.suboption = DCP_SUBOPTION_CONTROL_SIGNAL;
  block.length =
      static_cast<std::uint16_t>(
          signalBlockData.size());
  block.payload = signalBlockData;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_GET_SET_FRAME_ID;
  dcp.serviceId = PNDCPHeader::SET;
  dcp.serviceType = 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(const EthernetSocket& 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.first;
  block.suboption = key.second;
  block.length = 0;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_GET_SET_FRAME_ID;
  dcp.serviceId = PNDCPHeader::GET;
  dcp.serviceType = PNDCPHeader::REQUEST;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = 2;
  dcp.payload = block.ToBytes();
 
  sock.Send(BuildEthernetDcp(dst, src, dcp));
 
  auto responses = ReadResponse(sock, src, timeoutSec, /*once=*/true);
  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(const EthernetSocket& sock, const MacAddress& src, const std::string& target,
              const std::string& param, const std::string& value, int timeoutSec, bool permanent)
{
  const MacAddress dst = String2Mac(target);
 
  const Bytes frame = BuildSetParamRequest(dst,
                                           src,
                                           param,
                                           value,
                                           permanent);
  sock.Send(frame);
 
  try
  {
    const std::uint8_t blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DCP_BLOCK_ERROR_OK)
    {
      throw DCPError("DCP SET failed for '" + param + "': " + DcpBlockErrorName(blockError));
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
bool SetIp(const EthernetSocket& sock, const MacAddress& src, const std::string& target, const std::string& ip,
           const std::string& netmask, const std::string& gateway, bool permanent, int timeoutSec)
{
  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 std::uint16_t qualifier = permanent ? BlockQualifier::PERMANENT : BlockQualifier::TEMPORARY;
 
  PNDCPBlockRequest block;
  block.option = PNDCPBlock::IP_ADDRESS.first;
  block.suboption = PNDCPBlock::IP_ADDRESS.second;
  block.length = static_cast<std::uint16_t>(valueBytes.size() + 2);
  block.payload = {static_cast<std::uint8_t>(qualifier >> OneOctetShift), static_cast<std::uint8_t>(qualifier & LowByteMask)};
  block.payload.insert(block.payload.end(), valueBytes.begin(), valueBytes.end());
 
  const std::uint16_t padding = valueBytes.size() % 2 == 0 ? 0 : 1;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_GET_SET_FRAME_ID;
  dcp.serviceId = PNDCPHeader::SET;
  dcp.serviceType = PNDCPHeader::REQUEST;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(valueBytes.size() + 6 + padding);
  dcp.payload = block.ToBytes();
 
  sock.Send(BuildEthernetDcp(dst, src, dcp));
 
  try
  {
    const std::uint8_t blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DCP_BLOCK_ERROR_OK)
    {
      throw DCPError("DCP SET IP failed: " + DcpBlockErrorName(blockError));
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
void SendDiscover(const EthernetSocket& sock, const MacAddress& src, std::uint16_t responseDelay)
{
  const std::uint32_t xid = GenerateXid();
 
  PNDCPBlockRequest block;
  block.option = 0xFF;
  block.suboption = 0xFF;
  block.length = 0;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_IDENTIFY_REQUEST_FRAME_ID;
  dcp.serviceId = PNDCPHeader::IDENTIFY;
  dcp.serviceType = PNDCPHeader::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(const EthernetSocket& sock, const MacAddress& src, BlockKey blockType, const Bytes& value)
{
  const std::uint32_t xid = GenerateXid();
 
  PNDCPBlockRequest block;
  block.option = blockType.first;
  block.suboption = blockType.second;
  block.length = static_cast<std::uint16_t>(value.size());
  block.payload = value;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_IDENTIFY_REQUEST_FRAME_ID;
  dcp.serviceId = PNDCPHeader::IDENTIFY;
  dcp.serviceType = PNDCPHeader::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(const EthernetSocket& sock, const MacAddress& myMac, int 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();
    if (data.empty() || data.size() < 14)
    {
      continue;
    }
 
    EthernetHeader eth;
    try
    {
      eth = EthernetHeader::Parse(data);
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    if (eth.dst != myMac)
    {
      continue;
    }
 
    Bytes payload = eth.payload;
    if (eth.type == VLAN_ETHERTYPE)
    {
      if (payload.size() < 4)
      {
        continue;
      }
      const auto innerType = static_cast<std::uint16_t>((payload[2] << OneOctetShift) | payload[3]);
      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);
    }
    catch (const std::exception&)
    {
      continue;
    }
 
    if (dcp.serviceType != PNDCPHeader::RESPONSE)
    {
      continue;
    }
    if (expectedXid && dcp.xId != *expectedXid)
    {
      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, [&](std::uint8_t option, std::uint8_t suboption, const Bytes& blockPayload)
    {
      parsed[{option, suboption}] = blockPayload;
    });
 
    result[eth.src] = std::move(parsed);
    if (once)
    {
      break;
    }
  }
 
  return result;
}
 
void SendHello(const EthernetSocket& 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, std::uint8_t deviceRole)
{
  const std::uint32_t xid = GenerateXid();
  Bytes blocksData;
 
  // Name of Station block
  const Bytes nameBytes = ToVec(stationName);
  PNDCPBlockRequest nameBlock;
  nameBlock.option = DCP_OPTION_DEVICE;
  nameBlock.suboption = DCP_SUBOPTION_DEVICE_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 = DCP_OPTION_IP;
  ipBlock.suboption = DCP_SUBOPTION_IP_PARAMETER;
  ipBlock.length = static_cast<std::uint16_t>(ipPayload.size());
  ipBlock.payload = ipPayload;
  Bytes ipBlockBytes = ipBlock.ToBytes();
  blocksData.insert(blocksData.end(), ipBlockBytes.begin(), ipBlockBytes.end());
 
  // Device ID block
  const Bytes deviceIdBytes = {
      static_cast<std::uint8_t>(deviceId.first >> OneOctetShift), static_cast<std::uint8_t>(deviceId.first & LowByteMask),
      static_cast<std::uint8_t>(deviceId.second >> OneOctetShift), static_cast<std::uint8_t>(deviceId.second & LowByteMask)};
  PNDCPBlockRequest deviceIdBlock;
  deviceIdBlock.option = DCP_OPTION_DEVICE;
  deviceIdBlock.suboption = DCP_SUBOPTION_DEVICE_ID;
  deviceIdBlock.length = static_cast<std::uint16_t>(deviceIdBytes.size());
  deviceIdBlock.payload = deviceIdBytes;
  Bytes deviceIdBlockBytes = deviceIdBlock.ToBytes();
  blocksData.insert(blocksData.end(), deviceIdBlockBytes.begin(), deviceIdBlockBytes.end());
 
  // Device Role block
  PNDCPBlockRequest roleBlock;
  roleBlock.option = DCP_OPTION_DEVICE;
  roleBlock.suboption = DCP_SUBOPTION_DEVICE_ROLE;
  roleBlock.length = 2;
  roleBlock.payload = {deviceRole, 0x00};
  Bytes roleBlockBytes = roleBlock.ToBytes();
  blocksData.insert(blocksData.end(), roleBlockBytes.begin(), roleBlockBytes.end());
 
  // Device Initiative block
  PNDCPBlockRequest initBlock;
  initBlock.option = DCP_OPTION_DEVICE_INITIATIVE;
  initBlock.suboption = DCP_SUBOPTION_DEVICE_INITIATIVE;
  initBlock.length = 2;
  initBlock.payload = {0x00, static_cast<std::uint8_t>(DeviceInitiative::ISSUE_HELLO)};
  Bytes initBlockBytes = initBlock.ToBytes();
  blocksData.insert(blocksData.end(), initBlockBytes.begin(), initBlockBytes.end());
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_HELLO_FRAME_ID;
  dcp.serviceId = PNDCPHeader::HELLO;
  dcp.serviceType = PNDCPHeader::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(const EthernetSocket& sock, const MacAddress& /*myMac*/,
                                               int 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;
    if (eth.type == VLAN_ETHERTYPE)
    {
      if (payload.size() < 4)
      {
        continue;
      }
      const auto innerType = static_cast<std::uint16_t>((payload[2] << OneOctetShift) | payload[3]);
      if (innerType != PROFINET_ETHERTYPE)
      {
        continue;
      }
      payload = Bytes(payload.begin() + 4, 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 != PNDCPHeader::HELLO)
    {
      continue;
    }
    if (dcp.serviceType != PNDCPHeader::REQUEST)
    {
      continue;
    }
 
    std::map<BlockKey, Bytes> blocks;
    ForEachBlock(dcp.payload, [&](std::uint8_t option, std::uint8_t suboption, const Bytes& blockPayload)
    {
      blocks[{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, matching dcp.py's warn-and-continue behavior.
    }
  }
 
  return devices;
}
 
bool SignalDevice(const EthernetSocket& sock, const MacAddress& src, const std::string& target, int durationMs, int timeoutSec)
{
  const MacAddress dst = String2Mac(target);
  const Bytes frame = BuildDcpSignalRequest(dst, src);
  sock.Send(frame);
 
  try
  {
    const std::uint8_t blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DCP_BLOCK_ERROR_OK)
    {
      throw DCPError("DCP Signal failed: " + DcpBlockErrorName(blockError));
    }
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
bool ResetToFactory(const EthernetSocket& sock, const MacAddress& src, const std::string& target,
                    std::uint16_t mode, int timeoutSec)
{
  const MacAddress dst = String2Mac(target);
  const std::uint32_t xid = GenerateXid();
 
  const Bytes blockQualifier = {static_cast<std::uint8_t>(mode >> OneOctetShift), static_cast<std::uint8_t>(mode & LowByteMask)};
 
  PNDCPBlockRequest block;
  block.option = DCP_OPTION_CONTROL;
  block.suboption = DCP_SUBOPTION_CONTROL_RESET_TO_FACTORY;
  block.length = static_cast<std::uint16_t>(blockQualifier.size());
  block.payload = blockQualifier;
 
  PNDCPHeader dcp;
  dcp.frameId = DCP_GET_SET_FRAME_ID;
  dcp.serviceId = PNDCPHeader::SET;
  dcp.serviceType = PNDCPHeader::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 std::uint8_t blockError = RecvSetResponse(sock, src, timeoutSec);
    if (blockError != DCP_BLOCK_ERROR_OK)
    {
      throw DCPError("DCP Reset to Factory failed: " + DcpBlockErrorName(blockError));
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return true;
  }
  catch (const DCPTimeoutError&)
  {
    return false;
  }
}
 
} // namespace profinet::dcp