in_memory_ethernet.cpp

Go to the documentation of this file.

 
 
#include "profinet/sim/in_memory_ethernet.h"
 
#include <algorithm>
#include <stdexcept>
 
namespace profinet::sim
{
 
namespace
{
 
bool IsBroadcastOrMulticast(const MacAddress& mac)
{
  return mac == MacAddress{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} ||
         (mac[0] & 0x01U) != 0U;
}
 
bool ReadEthernetAddresses(const std::vector<std::uint8_t>& frame,
                           MacAddress& destination,
                           MacAddress& source)
{
  if (frame.size() < 12U)
  {
    return false;
  }
 
  std::copy_n(frame.begin(), destination.size(), destination.begin());
  std::copy_n(frame.begin() + 6, source.size(), source.begin());
  return true;
}
 
}  // namespace
 
InMemoryEthernetSocket::InMemoryEthernetSocket(InMemoryEthernetBus& busRef,
                                               MacAddress localMacRef)
    : bus(busRef), localMac(localMacRef)
{
  this->bus.Attach(this);
}
 
InMemoryEthernetSocket::~InMemoryEthernetSocket()
{
  bus.Detach(this);
}
 
void InMemoryEthernetSocket::Send(const std::vector<std::uint8_t>& frame)
{
  {
    std::lock_guard<std::mutex> lock(mutex);
    if (!connected)
    {
      throw std::runtime_error("In-memory Ethernet socket is disconnected");
    }
  }
 
  bus.Transmit(*this, frame);
}
 
void InMemoryEthernetSocket::SetTimeout(const std::chrono::milliseconds value)
{
  if (value.count() < 0)
  {
    throw std::invalid_argument("In-memory Ethernet socket timeout must be >= 0 ms");
  }
  std::lock_guard<std::mutex> lock(mutex);
  timeout = value;
}
 
void InMemoryEthernetSocket::SetReceiveEnabled(const bool enabled)
{
  {
    std::lock_guard<std::mutex> lock(mutex);
    receiveEnabled = enabled;
    if (!enabled)
    {
      receiveQueue.clear();
    }
  }
  condition.notify_all();
}
 
bool InMemoryEthernetSocket::ReceiveEnabled() const noexcept
{
  std::lock_guard<std::mutex> lock(mutex);
  return receiveEnabled;
}
 
std::vector<std::uint8_t> InMemoryEthernetSocket::Recv()
{
  std::unique_lock<std::mutex> lock(mutex);
 
  const auto hasData = [this]
  {
    return !receiveQueue.empty() || !connected || !receiveEnabled;
  };
 
  if (!hasData())
  {
    if (timeout.count() == 0)
    {
      condition.wait(lock, hasData);
    }
    else
    {
      condition.wait_for(lock, timeout, hasData);
    }
  }
 
  if (receiveQueue.empty())
  {
    return {};
  }
 
  std::vector<std::uint8_t> frame = std::move(receiveQueue.front());
  receiveQueue.pop_front();
  return frame;
}
 
void InMemoryEthernetSocket::Enqueue(const std::vector<std::uint8_t>& frame)
{
  {
    std::lock_guard<std::mutex> lock(mutex);
    if (!connected || !receiveEnabled)
    {
      return;
    }
    receiveQueue.push_back(frame);
  }
  condition.notify_one();
}
 
void InMemoryEthernetBus::Attach(InMemoryEthernetSocket* socket)
{
  if (socket == nullptr)
  {
    throw std::invalid_argument("Cannot attach a null in-memory Ethernet socket");
  }
  std::lock_guard<std::mutex> lock(mutex);
  // Multiple sockets may intentionally share one MAC (for example TX and RX
  // sockets owned by one production CyclicController).
  endpoints.push_back(socket);
}
 
void InMemoryEthernetBus::Detach(InMemoryEthernetSocket* socket)
{
  {
    std::lock_guard<std::mutex> busLock(mutex);
    endpoints.erase(std::remove(endpoints.begin(), endpoints.end(), socket),
                    endpoints.end());
    if (socket != nullptr)
    {
      std::lock_guard<std::mutex> socketLock(socket->mutex);
      socket->connected = false;
      socket->receiveQueue.clear();
    }
  }
  if (socket != nullptr)
  {
    socket->condition.notify_all();
  }
}
 
void InMemoryEthernetBus::Transmit(InMemoryEthernetSocket& sender,
                                   const std::vector<std::uint8_t>& frame)
{
  MacAddress destination{};
  MacAddress source{};
  if (!ReadEthernetAddresses(frame, destination, source))
  {
    throw std::invalid_argument(
        "In-memory Ethernet frame is shorter than an Ethernet header");
  }
 
  {
    std::lock_guard<std::mutex> lock(mutex);
    for (auto* endpoint : endpoints)
    {
      if (endpoint == nullptr || endpoint == &sender)
      {
        continue;
      }
 
      // A node may have multiple sockets sharing one MAC. Do not loop a frame
      // back into another socket of the same node.
      if (endpoint->LocalMac() == source)
      {
        continue;
      }
 
      const bool destinationMatches =
          IsBroadcastOrMulticast(destination) || endpoint->LocalMac() == destination;
      if (destinationMatches)
      {
        endpoint->Enqueue(frame);
      }
    }
  }
}
 
std::unique_ptr<InMemoryEthernetSocket>
InMemoryEthernetBus::CreateSocket(MacAddress localMac)
{
  return std::make_unique<InMemoryEthernetSocket>(*this, localMac);
}
 
std::size_t InMemoryEthernetBus::EndpointCount() const
{
  std::lock_guard<std::mutex> lock(mutex);
  return endpoints.size();
}
 
void InMemoryEthernetBus::ClearQueues()
{
  std::lock_guard<std::mutex> busLock(mutex);
  for (auto* endpoint : endpoints)
  {
    if (endpoint == nullptr)
    {
      continue;
    }
    std::lock_guard<std::mutex> socketLock(endpoint->mutex);
    endpoint->receiveQueue.clear();
  }
}
 
}  // namespace profinet::sim