ethernetPacketBackend.h

Go to the documentation of this file.

 
 
#pragma once
 
#if defined(_WIN32)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <winsock2.h>
#include <windows.h>
#endif
 
#include <pcap.h>
 
#include <asio/error_code.hpp>
#include <asio/io_context.hpp>
#include <asio/steady_timer.hpp>
 
#include <atomic>
#include <chrono>
#include <exception>
#include <future>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
#include "profinet/asioEthernetSocket.h"
 
#if defined(_WIN32)
#include <asio/windows/object_handle.hpp>
#else
#include <asio/posix/stream_descriptor.hpp>
#endif
 
namespace profinet
{
class AsioEthernetSocket::EthernetPacketBackend final
{
 public:
  EthernetPacketBackend(asio::io_context& ioContext, const std::string& interface, std::uint16_t ethertype);
 
  ~EthernetPacketBackend();
 
  EthernetPacketBackend(const EthernetPacketBackend&) = delete;
  EthernetPacketBackend& operator=(const EthernetPacketBackend&) = delete;
 
  EthernetPacketBackend(EthernetPacketBackend&&) = delete;
  EthernetPacketBackend& operator=(EthernetPacketBackend&&) = delete;
 
  void Send(const std::vector<std::uint8_t>& frame);
 
  void SetTimeout(std::chrono::milliseconds newTimeout);
 
  [[nodiscard]] std::vector<std::uint8_t> Recv();
 
 private:
  struct ReceiveOperation
  {
    enum class State : std::uint8_t
    {
      Pending,
      Received,
      TimedOut,
      Failed
    };
 
    explicit ReceiveOperation(asio::io_context& ioContext)
        : timeoutTimer(ioContext), pollTimer(ioContext)
    {
    }
 
    std::atomic<State> state{State::Pending};
 
    std::atomic<std::size_t> pendingHandlers{0U};
 
    std::promise<std::vector<std::uint8_t>> completion;
 
    std::vector<std::uint8_t> frame;
 
    std::exception_ptr error;
 
    std::mutex resultMutex;
 
    asio::steady_timer timeoutTimer;
 
    asio::steady_timer pollTimer;
  };
 
  void OpenCapture(const std::string& interface);
 
  void InitializePacketWait();
 
  void AsyncWaitForPacket(const std::shared_ptr<ReceiveOperation>& operation);
 
  void HandlePacketReady(const std::shared_ptr<ReceiveOperation>& operation, const asio::error_code& error);
 
  void HandleTimeout(const std::shared_ptr<ReceiveOperation>& operation, const asio::error_code& error);
 
  void RearmPacketWait(const std::shared_ptr<ReceiveOperation>& operation);
 
  void FailOperation(const std::shared_ptr<ReceiveOperation>& operation, std::exception_ptr error);
 
  void CancelPacketWait(const std::shared_ptr<ReceiveOperation>& operation, asio::error_code& error);
 
  void CompleteHandler(const std::shared_ptr<ReceiveOperation>& operation);
 
  int CaptureNextFrame(std::vector<std::uint8_t>& frame);
 
  friend class EthernetPacketBackendTestFixture;
 
  [[nodiscard]] bool MatchesEtherType(const std::vector<std::uint8_t>& frame) const;
 
  asio::io_context& ioContext;
 
  pcap_t* capture{nullptr};
 
  std::uint16_t ethertype{0U};
 
  std::chrono::milliseconds timeout{std::chrono::milliseconds::zero()};
 
  std::mutex timeoutMutex;
 
  std::mutex captureMutex;
 
  std::mutex receiveMutex;
 
  bool usePolling{false};
 
#if defined(_WIN32)
  asio::windows::object_handle packetWait;
#else
  asio::posix::stream_descriptor packetWait;
#endif
};
 
} // namespace profinet