rpcTransport.cpp

Go to the documentation of this file.

 
 
#include "profinet/rpcTransport.h"
 
#include <algorithm>
#include <system_error>
#include <utility>
#include <vector>
 
#include "profinet/exceptions.h"
 
namespace profinet::rpc
{
 
RpcTransport::RpcTransport(asio::io_context& ioContext)
    : ioContext(ioContext),
      socket(ioContext)
{
}
void RpcTransport::Open(
    const std::string& address,
    std::uint16_t port,
    bool isListener)
{
  asio::error_code ec;
  const auto ipAddress = asio::ip::make_address_v4(address, ec);
 
  if (ec)
  {
    throw std::system_error(ec, "Invalid IPv4 address: " + address);
  }
 
  if (!socket.is_open())
  {
    socket.open(asio::ip::udp::v4(), ec);
    if (ec)
    {
      throw std::system_error(ec, "Failed to open UDP socket");
    }
 
    // Allow socket reuse if needed
    socket.set_option(asio::ip::udp::socket::reuse_address(true), ec);
 
    if (isListener)
    {
      // BIND to the specified local interface and port!
      asio::ip::udp::endpoint listenEndpoint(ipAddress, port);
      socket.bind(listenEndpoint, ec);
      if (ec)
      {
        throw std::system_error(ec, "Failed to bind UDP socket to port " + std::to_string(port));
      }
    }
  }
 
  if (!isListener)
  {
    // Target endpoint for outgoing client requests
    endpoint = asio::ip::udp::endpoint(ipAddress, port);
  }
}
/*
void RpcTransport::Open(
    const std::string& address,
    std::uint16_t port,
    bool isListener)
{
  asio::error_code ec;
 
  const auto ipAddress =
      asio::ip::make_address_v4(address, ec);
 
  if (ec)
  {
    throw std::system_error(
        ec,
        "Invalid IPv4 address: " + address);
  }
 
  endpoint =
      asio::ip::udp::endpoint(ipAddress, port);
 
  if (!socket.is_open())
  {
    socket.open(
        asio::ip::udp::v4(),
        ec);
 
    if (ec)
    {
      throw std::system_error(
          ec,
          "Failed to open UDP socket");
    }
  }
}
*/
Bytes RpcTransport::Receive(
    std::chrono::milliseconds timeout,
    asio::ip::udp::endpoint& remoteEndpoint)
{
  if (!socket.is_open())
  {
    throw std::system_error(
        asio::error::not_connected,
        "UDP socket is not open");
  }
 
  if (timeout <= std::chrono::milliseconds::zero())
  {
    throw std::system_error(
        asio::error::invalid_argument,
        "UDP receive timeout must be greater than zero");
  }
 
  Bytes receiveBuffer(RECEIVE_BUFFER_LENGTH);
  asio::error_code receiveError;
  std::size_t receivedBytes = 0;
 
  bool receiveCompleted = false;
  bool timedOut = false;
 
  asio::steady_timer timer(ioContext);
 
  socket.async_receive_from(
      asio::buffer(receiveBuffer),
      remoteEndpoint,
      [&](const asio::error_code& ec, std::size_t bytes)
  {
    receiveError = ec;
    receivedBytes = bytes;
    receiveCompleted = true;
 
    asio::error_code timerError;
    timer.cancel(timerError);
  });
 
  timer.expires_after(timeout);
 
  timer.async_wait(
      [&](const asio::error_code& ec)
  {
    if (!ec)
    {
      timedOut = true;
 
      asio::error_code cancelError;
      socket.cancel(cancelError);
    }
  });
 
  ioContext.restart();
  ioContext.run();
 
  if (timedOut && !receiveCompleted)
  {
    throw RPCTimeoutError("UDP receive timed out");
  }
 
  if (receiveError)
  {
    if (receiveError == asio::error::operation_aborted && timedOut)
    {
      throw RPCTimeoutError("UDP receive timed out");
    }
 
    throw std::system_error(
        receiveError,
        "Failed to receive UDP datagram");
  }
 
  receiveBuffer.resize(receivedBytes);
  return receiveBuffer;
}
 
void RpcTransport::SendTo(
    const Bytes& data,
    const asio::ip::udp::endpoint& targetEndpoint)
{
  if (!socket.is_open())
  {
    throw std::system_error(
        asio::error::not_connected,
        "UDP socket is not open");
  }
 
  asio::error_code ec;
 
  socket.send_to(
      asio::buffer(data),
      targetEndpoint,
      0,
      ec);
 
  if (ec)
  {
    throw std::system_error(
        ec,
        "Failed to send UDP datagram");
  }
}
 
Bytes RpcTransport::SendReceive(
    const Bytes& data,
    std::chrono::milliseconds timeout)
{
  if (!socket.is_open())
  {
    throw std::system_error(
        asio::error::not_connected,
        "UDP socket is not open");
  }
 
  if (timeout <= std::chrono::milliseconds::zero())
  {
    throw std::system_error(
        asio::error::invalid_argument,
        "UDP receive timeout must be greater than zero");
  }
 
  asio::error_code sendError;
 
  socket.send_to(
      asio::buffer(data),
      endpoint,
      0,
      sendError);
 
  if (sendError)
  {
    throw std::system_error(
        sendError,
        "Failed to send UDP datagram");
  }
 
  Bytes receiveBuffer(RECEIVE_BUFFER_LENGTH);
 
  asio::ip::udp::endpoint senderEndpoint;
 
  asio::error_code receiveError;
  std::size_t receivedBytes = 0;
 
  bool receiveCompleted = false;
  bool timedOut = false;
 
  asio::steady_timer timer(ioContext);
 
  socket.async_receive_from(
      asio::buffer(receiveBuffer),
      senderEndpoint,
      [&](const asio::error_code& ec, std::size_t bytes)
  {
    receiveError = ec;
    receivedBytes = bytes;
    receiveCompleted = true;
 
    asio::error_code timerError;
    timer.cancel(timerError);
  });
 
  timer.expires_after(timeout);
 
  timer.async_wait(
      [&](const asio::error_code& ec)
  {
    if (!ec)
    {
      timedOut = true;
 
      asio::error_code cancelError;
      socket.cancel(cancelError);
    }
  });
 
  ioContext.restart();
  ioContext.run();
 
  if (timedOut && !receiveCompleted)
  {
    throw RPCTimeoutError(
        "UDP receive timed out");
  }
 
  if (receiveError)
  {
    if (receiveError == asio::error::operation_aborted &&
        timedOut)
    {
      throw RPCTimeoutError(
          "UDP receive timed out");
    }
 
    throw std::system_error(
        receiveError,
        "Failed to receive UDP datagram");
  }
 
  receiveBuffer.resize(receivedBytes);
 
  return receiveBuffer;
}
 
void RpcTransport::Send(const Bytes& data)
{
  if (!socket.is_open())
  {
    throw std::system_error(
        asio::error::not_connected,
        "UDP socket is not open");
  }
 
  asio::error_code ec;
 
  socket.send_to(
      asio::buffer(data),
      endpoint,
      0,
      ec);
 
  if (ec)
  {
    throw std::system_error(
        ec,
        "Failed to send UDP datagram");
  }
}
 
void RpcTransport::Close() noexcept
{
  asio::error_code ec;
 
  if (socket.is_open())
  {
    socket.cancel(ec);
    socket.close(ec);
  }
}
 
bool RpcTransport::IsOpen() const noexcept
{
  return socket.is_open();
}
 
} // namespace profinet::rpc