test_dcp_asioIntegration.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <asio.hpp>
#include <cstdint>
#include <exception>
#include <string>
#include <thread>
#include <vector>
 
#include "profinet/AsioIoContextRunner.h"
#include "profinet/asioEthernetSocket.h"
#include "profinet/dcp.h"
#include "profinet/exceptions.h"
#include "profinet/protocol.h"
 
using namespace profinet;
using namespace profinet::dcp;
using namespace std::chrono_literals;
#ifndef PROFINET_TEST_INTERFACE
#define PROFINET_TEST_INTERFACE ""
#endif
namespace
{
[[nodiscard]] std::string GetIntegrationTestInterface()
{
  // const char* interfaceName = std::getenv("PROFINET_TEST_INTERFACE");
 
  // return interfaceName != nullptr ? interfaceName : std::string{};
  return PROFINET_TEST_INTERFACE;
}
 
const MacAddress kControllerMac{0x08, 0x00, 0x27, 0x31, 0x39, 0xDC};
 
const MacAddress kDeviceMac{0xA0, 0xD3, 0x85, 0x00, 0xF6, 0x13};
 
Bytes BuildDcpResponseFrame(const MacAddress& destination, const MacAddress& source, std::uint32_t xid, const Bytes& block, bool vlan = false)
{
  PNDCPHeader dcp;
  dcp.frameId = DcpFrameId::GetSet;
  dcp.serviceId = DcpServiceId::Get;
  dcp.serviceType = DcpServiceType::ResponseSuccess;
  dcp.xId = xid;
  dcp.respDelay = 0;
  dcp.length = static_cast<std::uint16_t>(block.size());
  dcp.payload = block;
 
  const Bytes dcpBytes = dcp.ToBytes();
 
  Bytes frame;
  frame.reserve(14U + (vlan ? 4U : 0U) + dcpBytes.size());
 
  frame.insert(frame.end(), destination.begin(), destination.end());
 
  frame.insert(frame.end(), source.begin(), source.end());
 
  if (vlan)
  {
    frame.insert(frame.end(), {
                                  0x81, 0x00, // 802.1Q TPID.
                                  0xC0, 0x00, // Priority-tagged VLAN TCI.
                                  0x88, 0x92  // Inner EtherType: PROFINET.
                              });
  }
  else
  {
    frame.insert(frame.end(), {
                                  0x88, 0x92 // PROFINET EtherType.
                              });
  }
 
  frame.insert(frame.end(), dcpBytes.begin(), dcpBytes.end());
 
  return frame;
}
 
Bytes BuildStationNameBlock(const std::string& stationName)
{
  const Bytes nameBytes(stationName.begin(), stationName.end());
 
  PNDCPBlockRequest block;
  block.option = DcpOption::Device;
  block.suboption = static_cast<std::uint8_t>(DcpDeviceSuboption::Name);
  block.length = static_cast<std::uint16_t>(nameBytes.size());
  block.payload = nameBytes;
 
  Bytes result = block.ToBytes();
 
  if ((nameBytes.size() % 2U) != 0U)
  {
    result.push_back(0x00);
  }
 
  return result;
}
 
template <typename Predicate>
Bytes ReceiveMatchingFrame(AsioEthernetSocket& socket, Predicate&& predicate)
{
  socket.SetTimeout(100ms);
 
  for (int attempt = 0; attempt < 10; ++attempt)
  {
    const Bytes frame = socket.Recv();
 
    if (frame.empty())
    {
      return {};
    }
 
    if (predicate(frame))
    {
      return frame;
    }
  }
 
  return {};
}
 
class DcpAsioIntegrationTests : public ::testing::Test
{
 protected:
  void SetUp() override
  {
    testInterface = GetIntegrationTestInterface();
 
    if (testInterface.empty())
    {
      GTEST_SKIP() << "PROFINET_TEST_INTERFACE is not set. "
                   << "Set it before starting VS Code, for example: "
                   << "export PROFINET_TEST_INTERFACE=enp0s8";
    }
    ASSERT_NO_THROW(socket = std::make_unique<AsioEthernetSocket>(ioContext, testInterface, 0));
 
    ASSERT_NO_THROW(peerSocket = std::make_unique<AsioEthernetSocket>(ioContext, testInterface, 0));
  }
 
  void TearDown() override
  {
    peerSocket.reset();
    socket.reset();
  }
 
  asio::io_context ioContext;
 
  AsioIoContextRunner runner{ioContext};
 
  std::unique_ptr<AsioEthernetSocket> socket;
 
  std::unique_ptr<AsioEthernetSocket> peerSocket;
 
  std::string testInterface;
};
 
} // namespace
 
TEST_F(DcpAsioIntegrationTests, SendDiscoverTransmitsIdentifyRequest)
{
  dcp::SendDiscover(*socket, kControllerMac);
 
  const Bytes frame = ReceiveMatchingFrame(*peerSocket, [](const Bytes& data)
  {
    if (data.size() < 14) // EthernetHeader::kFixedSize
    {
      return false;
    }
 
    try
    {
      const EthernetHeader ethernet = EthernetHeader::Parse(data);
 
      if (ethernet.dst != String2Mac(DCP_MULTICAST_MAC))
      {
        return false;
      }
 
      if (ethernet.src != kControllerMac)
      {
        return false;
      }
 
      if (ethernet.type != PROFINET_ETHERTYPE)
      {
        return false;
      }
 
      const PNDCPHeader dcp = PNDCPHeader::Parse(ethernet.payload);
 
      return dcp.frameId == DcpFrameId::IdentifyRequest &&
             dcp.serviceId == DcpServiceId::Identify &&
             dcp.serviceType == DcpServiceType::Request &&
             dcp.respDelay == DEFAULT_RESPONSE_DELAY_FACTOR;
    }
    catch (const std::exception&)
    {
      return false;
    }
  });
 
  ASSERT_FALSE(frame.empty());
 
  const EthernetHeader ethernet = EthernetHeader::Parse(frame);
 
  EXPECT_EQ(ethernet.dst, String2Mac(DCP_MULTICAST_MAC));
  EXPECT_EQ(ethernet.src, kControllerMac);
  EXPECT_EQ(ethernet.type, PROFINET_ETHERTYPE);
 
  const PNDCPHeader dcp = PNDCPHeader::Parse(ethernet.payload);
 
  EXPECT_EQ(dcp.frameId, DcpFrameId::IdentifyRequest);
 
  EXPECT_EQ(dcp.serviceId, DcpServiceId::Identify);
 
  EXPECT_EQ(dcp.serviceType, DcpServiceType::Request);
 
  EXPECT_EQ(dcp.respDelay, DEFAULT_RESPONSE_DELAY_FACTOR);
 
  EXPECT_NE(dcp.xId, 0U);
}
 
TEST_F(DcpAsioIntegrationTests, ReadResponseParsesAsioEthernetFrame)
{
  const Bytes block = BuildStationNameBlock("AUMA");
 
  const std::uint32_t xid = 0x12345678U;
 
  const Bytes response = BuildDcpResponseFrame(kControllerMac, kDeviceMac, xid, block);
 
  peerSocket->Send(response);
 
  const ResponseMap result = dcp::ReadResponse(*socket, kControllerMac, 1.0, true, xid);
 
  ASSERT_EQ(result.size(), 1U);
 
  const auto deviceIt = result.find(kDeviceMac);
 
  ASSERT_NE(deviceIt, result.end());
 
  const auto blockIt = deviceIt->second.find(MakeBlockKey(DcpOption::Device, static_cast<std::uint8_t>(DcpDeviceSuboption::Name)));
 
  ASSERT_NE(blockIt, deviceIt->second.end());
 
  EXPECT_EQ(blockIt->second, (Bytes{'A', 'U', 'M', 'A'}));
}
 
TEST_F(DcpAsioIntegrationTests, ReadResponseParsesVlanTaggedAsioEthernetFrame)
{
  const Bytes block = BuildStationNameBlock("AUMA");
 
  const std::uint32_t xid = 0x23456789U;
 
  const Bytes response = BuildDcpResponseFrame(kControllerMac, kDeviceMac, xid, block, true);
 
  peerSocket->Send(response);
 
  const ResponseMap result = dcp::ReadResponse(*socket, kControllerMac, 1.0, true, xid);
 
  ASSERT_EQ(result.size(), 1U);
 
  const auto deviceIt = result.find(kDeviceMac);
 
  ASSERT_NE(deviceIt, result.end());
 
  const auto blockIt = deviceIt->second.find(MakeBlockKey(DcpOption::Device, static_cast<std::uint8_t>(DcpDeviceSuboption::Name)));
 
  ASSERT_NE(blockIt, deviceIt->second.end());
 
  EXPECT_EQ(blockIt->second, (Bytes{'A', 'U', 'M', 'A'}));
}
 
TEST_F(DcpAsioIntegrationTests, GetParamPerformsAsioRoundTrip)
{
  std::exception_ptr peerException;
  Bytes receivedRequest;
 
  std::jthread peerWorker([&]
  {
    try
    {
      peerSocket->SetTimeout(1000ms);
 
      receivedRequest = peerSocket->Recv();
 
      if (receivedRequest.empty())
      {
        throw std::runtime_error("DCP GET request was not received");
      }
 
      const EthernetHeader requestEthernet = EthernetHeader::Parse(receivedRequest);
 
      EXPECT_EQ(requestEthernet.dst, kDeviceMac);
 
      EXPECT_EQ(requestEthernet.src, kControllerMac);
 
      EXPECT_EQ(requestEthernet.type, PROFINET_ETHERTYPE);
 
      const PNDCPHeader requestDcp = PNDCPHeader::Parse(requestEthernet.payload);
 
      EXPECT_EQ(requestDcp.frameId, DcpFrameId::GetSet);
 
      EXPECT_EQ(requestDcp.serviceId, DcpServiceId::Get);
 
      EXPECT_EQ(requestDcp.serviceType, DcpServiceType::Request);
 
      EXPECT_EQ(requestDcp.length, 2U); // need to check specs!!
 
      EXPECT_EQ(requestDcp.payload.size(), 4U);
      EXPECT_EQ(requestDcp.payload[0], static_cast<std::uint8_t>(DcpOption::Device));
 
      EXPECT_EQ(requestDcp.payload[1], static_cast<std::uint8_t>(DcpDeviceSuboption::Name));
 
      EXPECT_EQ(requestDcp.payload[2], 0x00); // block length = 0
      EXPECT_EQ(requestDcp.payload[3], 0x00);
 
      const Bytes responseBlock = BuildStationNameBlock("AUMA");
 
      const Bytes response = BuildDcpResponseFrame(kControllerMac, kDeviceMac, requestDcp.xId, responseBlock);
 
      peerSocket->Send(response);
    }
    catch (...)
    {
      peerException = std::current_exception();
    }
  });
 
  const auto result = dcp::GetParam(*socket, kControllerMac, Mac2String(kDeviceMac), "name", 1);
 
  peerWorker.join();
 
  if (peerException)
  {
    std::rethrow_exception(peerException);
  }
 
  ASSERT_FALSE(receivedRequest.empty());
  ASSERT_TRUE(result.has_value());
 
  EXPECT_EQ(*result, (Bytes{'A', 'U', 'M', 'A'}));
}