ethernetPacketBackend.cpp

Go to the documentation of this file.

 
 
#include "profinet/ethernetPacketBackend.h"
 
#include <algorithm>
#include <limits>
#include <string>
#include <utility>
 
#include "profinet/exceptions.h"
#include "profinet/util.h"
 
namespace profinet
{
namespace
{
constexpr std::size_t kEthernetHeaderSize = 14U;
constexpr int kCaptureTimeoutMilliseconds = 1;
 
[[noreturn]] void ThrowPcapError(const std::string& operation, pcap_t* capture, int errorCode)
{
  const char* detail = capture != nullptr ? pcap_geterr(capture) : nullptr;
 
  std::string message = operation;
 
  if (detail != nullptr && *detail != '\0')
  {
    message += ": ";
    message += detail;
  }
  else
  {
    message += " (libpcap error " + std::to_string(errorCode) + ")";
  }
 
  if (errorCode == PCAP_ERROR_PERM_DENIED || errorCode == PCAP_ERROR_PROMISC_PERM_DENIED)
  {
    throw PermissionDeniedError(message);
  }
 
  throw SocketError(message);
}
 
std::string ResolveCaptureDevice(const std::string& requested)
{
  char errorBuffer[PCAP_ERRBUF_SIZE]{};
 
  pcap_if_t* devices = nullptr;
 
  const int result = pcap_findalldevs(&devices, errorBuffer);
 
  if (result != 0)
  {
    throw SocketError("Failed to enumerate packet-capture devices: " + std::string(errorBuffer));
  }
 
  std::string resolved = requested;
 
  for (const pcap_if_t* device = devices; device != nullptr; device = device->next)
  {
    if (device->name != nullptr && requested == device->name)
    {
      resolved = device->name;
      break;
    }
 
    if (device->description != nullptr && requested == device->description)
    {
      resolved = device->name;
      break;
    }
  }
 
  pcap_freealldevs(devices);
 
  return resolved;
}
 
} // namespace
 
AsioEthernetSocket::EthernetPacketBackend::EthernetPacketBackend(asio::io_context& ioContext, const std::string& interface, std::uint16_t ethertype)
    : ioContext(ioContext), ethertype(ethertype)
#ifdef _WIN32
      ,
      packetWait(ioContext)
#else
      ,
      packetWait(ioContext)
#endif
{
  OpenCapture(interface);
  InitializePacketWait();
}
 
AsioEthernetSocket::EthernetPacketBackend::~EthernetPacketBackend()
{
  asio::error_code error;
 
  packetWait.cancel(error);
  packetWait.close(error);
 
  std::lock_guard captureLock(captureMutex);
 
  if (capture != nullptr)
  {
    pcap_close(capture);
    capture = nullptr;
  }
}
 
void AsioEthernetSocket::EthernetPacketBackend::OpenCapture(const std::string& interface)
{
  if (interface.empty())
  {
    throw SocketError("Ethernet interface cannot be empty");
  }
 
  const std::string deviceName = ResolveCaptureDevice(interface);
 
  char errorBuffer[PCAP_ERRBUF_SIZE]{};
 
  capture = pcap_create(deviceName.c_str(), errorBuffer);
 
  if (capture == nullptr)
  {
    throw SocketError("Failed to create packet capture on '" + interface + "': " + errorBuffer);
  }
 
  auto closeCapture = [this]()
  {
    if (capture != nullptr)
    {
      pcap_close(capture);
      capture = nullptr;
    }
  };
 
  if (pcap_set_snaplen(capture, static_cast<int>(MAX_ETHERNET_FRAME)) != 0)
  {
    const std::string message = pcap_geterr(capture);
    closeCapture();
    throw SocketError("Failed to configure packet capture snap length: " + message);
  }
 
  if (pcap_set_promisc(capture, 1) != 0)
  {
    const std::string message = pcap_geterr(capture);
    closeCapture();
    throw SocketError("Failed to configure packet capture promiscuous mode: " + message);
  }
 
  if (pcap_set_timeout(capture, kCaptureTimeoutMilliseconds) != 0)
  {
    const std::string message = pcap_geterr(capture);
    closeCapture();
    throw SocketError("Failed to configure packet capture timeout: " + message);
  }
 
  if (pcap_set_immediate_mode(capture, 1) != 0)
  {
    const std::string message = pcap_geterr(capture);
    closeCapture();
    throw SocketError("Failed to enable immediate packet delivery: " + message);
  }
 
  const int activateResult = pcap_activate(capture);
 
  if (activateResult < 0)
  {
    try
    {
      ThrowPcapError("Failed to activate packet capture on '" + interface + "'", capture, activateResult);
    }
    catch (...)
    {
      closeCapture();
      throw;
    }
  }
 
  if (pcap_datalink(capture) != DLT_EN10MB)
  {
    const int dataLink = pcap_datalink(capture);
    const std::string name = pcap_datalink_val_to_name(dataLink) != nullptr
                                 ? pcap_datalink_val_to_name(dataLink)
                                 : "unknown";
 
    closeCapture();
 
    throw SocketError("Interface '" + interface + "' does not expose Ethernet frames; libpcap data link type is " + name);
  }
 
  if (pcap_setnonblock(capture, 1, errorBuffer) != 0)
  {
    const std::string message = errorBuffer;
    closeCapture();
    throw SocketError("Failed to configure non-blocking packet capture: " + message);
  }
}
 
void AsioEthernetSocket::EthernetPacketBackend::Send(const std::vector<std::uint8_t>& frame)
{
  if (frame.size() < kEthernetHeaderSize)
  {
    throw std::invalid_argument("Ethernet frame is shorter than the Ethernet header");
  }
 
  if (frame.size() > static_cast<std::size_t>(std::numeric_limits<int>::max()))
  {
    throw std::invalid_argument("Ethernet frame is too large");
  }
 
  std::lock_guard captureLock(captureMutex);
 
  if (capture == nullptr)
  {
    throw SocketError("Ethernet packet backend is not open");
  }
 
  const int result = pcap_sendpacket(capture, frame.data(), static_cast<int>(frame.size()));
 
  if (result != 0)
  {
    ThrowPcapError("Failed to send Ethernet frame", capture, result);
  }
}
 
void AsioEthernetSocket::EthernetPacketBackend::SetTimeout(std::chrono::milliseconds newTimeout)
{
  std::lock_guard lock(timeoutMutex);
 
  this->timeout = newTimeout > std::chrono::milliseconds::zero()
                      ? newTimeout
                      : std::chrono::milliseconds::zero();
}
 
std::vector<std::uint8_t>
AsioEthernetSocket::EthernetPacketBackend::Recv()
{
  std::unique_lock receiveLock(receiveMutex);
 
  std::chrono::milliseconds receiveTimeout;
 
  {
    std::lock_guard timeoutLock(timeoutMutex);
    receiveTimeout = timeout;
  }
 
  const bool hasTimeout = receiveTimeout > std::chrono::milliseconds::zero();
 
  const auto operation = std::make_shared<ReceiveOperation>(ioContext);
 
  operation->pendingHandlers.store(hasTimeout ? 2U : 1U, std::memory_order_release);
 
  std::future<std::vector<std::uint8_t>> completion = operation->completion.get_future();
 
  AsyncWaitForPacket(operation);
 
  if (hasTimeout)
  {
    operation->timeoutTimer.expires_after(receiveTimeout);
 
    operation->timeoutTimer.async_wait([this, operation](const asio::error_code& error)
    {
      HandleTimeout(operation, error);
    });
  }
 
  return completion.get();
}
 
void AsioEthernetSocket::EthernetPacketBackend::HandlePacketReady(const std::shared_ptr<ReceiveOperation>& operation, const asio::error_code& error)
{
  if (error)
  {
    if (error != asio::error::operation_aborted)
    {
      FailOperation(operation, std::make_exception_ptr(SocketError("Ethernet packet wait failed: " + error.message())));
    }
 
    CompleteHandler(operation);
    return;
  }
 
  if (operation->state.load(std::memory_order_acquire) != ReceiveOperation::State::Pending)
  {
    CompleteHandler(operation);
    return;
  }
 
  std::vector<std::uint8_t> frame;
 
  const int result = CaptureNextFrame(frame);
 
  if (result == 1)
  {
    if (MatchesEtherType(frame))
    {
      ReceiveOperation::State expected = ReceiveOperation::State::Pending;
 
      if (operation->state.compare_exchange_strong(expected, ReceiveOperation::State::Received, std::memory_order_acq_rel))
      {
        {
          std::lock_guard lock(operation->resultMutex);
          operation->frame = std::move(frame);
        }
 
        asio::error_code cancelError;
        operation->timeoutTimer.cancel(cancelError);
        CancelPacketWait(operation, cancelError);
      }
    }
    else
    {
      RearmPacketWait(operation);
    }
  }
  else if (result == 0)
  {
    RearmPacketWait(operation);
  }
  else if (result == -2)
  {
    FailOperation(operation, std::make_exception_ptr(SocketError("Ethernet packet capture was terminated")));
  }
  else
  {
    std::string message = "Failed to receive Ethernet frame";
 
    {
      std::lock_guard captureLock(captureMutex);
 
      if (capture != nullptr)
      {
        const char* detail = pcap_geterr(capture);
 
        if (detail != nullptr && *detail != '\0')
        {
          message += ": ";
          message += detail;
        }
      }
    }
 
    FailOperation(operation, std::make_exception_ptr(SocketError(message)));
  }
 
  CompleteHandler(operation);
}
 
void AsioEthernetSocket::EthernetPacketBackend::HandleTimeout(const std::shared_ptr<ReceiveOperation>& operation, const asio::error_code& error)
{
  if (!error)
  {
    ReceiveOperation::State expected = ReceiveOperation::State::Pending;
 
    if (operation->state.compare_exchange_strong(expected, ReceiveOperation::State::TimedOut, std::memory_order_acq_rel))
    {
      asio::error_code cancelError;
      CancelPacketWait(operation, cancelError);
    }
  }
 
  CompleteHandler(operation);
}
 
void AsioEthernetSocket::EthernetPacketBackend::RearmPacketWait(const std::shared_ptr<ReceiveOperation>& operation)
{
  if (operation->state.load(std::memory_order_acquire) != ReceiveOperation::State::Pending)
  {
    return;
  }
 
  operation->pendingHandlers.fetch_add(1U, std::memory_order_acq_rel);
 
  if (operation->state.load(std::memory_order_acquire) != ReceiveOperation::State::Pending)
  {
    operation->pendingHandlers.fetch_sub(1U, std::memory_order_acq_rel);
 
    return;
  }
 
  try
  {
    AsyncWaitForPacket(operation);
  }
  catch (...)
  {
    operation->pendingHandlers.fetch_sub(1U, std::memory_order_acq_rel);
 
    FailOperation(operation, std::current_exception());
  }
}
 
void AsioEthernetSocket::EthernetPacketBackend::FailOperation(const std::shared_ptr<ReceiveOperation>& operation, std::exception_ptr error)
{
  ReceiveOperation::State expected = ReceiveOperation::State::Pending;
 
  if (!operation->state.compare_exchange_strong(expected, ReceiveOperation::State::Failed, std::memory_order_acq_rel))
  {
    return;
  }
 
  {
    std::lock_guard lock(operation->resultMutex);
    operation->error = std::move(error);
  }
 
  asio::error_code cancelError;
 
  CancelPacketWait(operation, cancelError);
  operation->timeoutTimer.cancel(cancelError);
}
 
void AsioEthernetSocket::EthernetPacketBackend::CompleteHandler(const std::shared_ptr<ReceiveOperation>& operation)
{
  if (operation->pendingHandlers.fetch_sub(1U, std::memory_order_acq_rel) != 1U)
  {
    return;
  }
 
  const ReceiveOperation::State state = operation->state.load(std::memory_order_acquire);
 
  std::vector<std::uint8_t> frame;
  std::exception_ptr error;
 
  {
    std::lock_guard lock(operation->resultMutex);
 
    frame = std::move(operation->frame);
    error = operation->error;
  }
 
  if (state == ReceiveOperation::State::Failed)
  {
    operation->completion.set_exception(error);
  }
  else if (state == ReceiveOperation::State::TimedOut)
  {
    operation->completion.set_value({});
  }
  else
  {
    operation->completion.set_value(std::move(frame));
  }
}
 
int AsioEthernetSocket::EthernetPacketBackend::CaptureNextFrame(std::vector<std::uint8_t>& frame)
{
  std::lock_guard captureLock(captureMutex);
 
  if (capture == nullptr)
  {
    throw SocketError("Ethernet packet backend is not open");
  }
 
  pcap_pkthdr* header = nullptr;
  const u_char* data = nullptr;
 
  const int result = pcap_next_ex(capture, &header, &data);
 
  if (result == 1 && header != nullptr && data != nullptr)
  {
    frame.assign(data, data + header->caplen);
  }
 
  return result;
}
 
bool AsioEthernetSocket::EthernetPacketBackend::MatchesEtherType(const std::vector<std::uint8_t>& frame) const
{
  if (ethertype == 0U)
  {
    return true;
  }
 
  if (frame.size() < kEthernetHeaderSize)
  {
    return false;
  }
 
  const std::size_t etherTypeOffset = SkipVlanTags(frame);
 
  if (etherTypeOffset + sizeof(std::uint16_t) > frame.size())
  {
    return false;
  }
 
  const auto frameType = static_cast<std::uint16_t>((static_cast<std::uint16_t>(frame[etherTypeOffset]) << 8U) |
                                                    static_cast<std::uint16_t>(frame[etherTypeOffset + 1U]));
 
  return frameType == ethertype;
}
 
} // namespace profinet