udpSocket.cpp

Go to the documentation of this file.

 
 
#include "profinet/udpSocket.h"
 
#include <algorithm>
#include <asio.hpp>
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <system_error>
#include <utility>
#include <vector>
 
#include "profinet/exceptions.h"
 
namespace profinet
{
namespace
{
 
[[noreturn]] void ThrowSocketError(
    const std::string& operation,
    const asio::error_code& error)
{
  if (error == asio::error::access_denied)
  {
    throw PermissionDeniedError(operation + ": " + error.message());
  }
 
  throw SocketError(operation + ": " + error.message());
}
 
} // namespace
 
UdpSocket::UdpSocket(
    const std::string& host,
    std::uint16_t port,
    std::chrono::duration<double> timeout)
    : ioContext(std::make_unique<asio::io_context>()),
      socket(std::make_unique<asio::ip::udp::socket>(*ioContext))
{
  asio::ip::udp::resolver resolver(*ioContext);
  asio::error_code ec;
 
  const auto endpoints = resolver.resolve(
      asio::ip::udp::v4(),
      host,
      std::to_string(port),
      ec);
 
  if (ec)
  {
    ThrowSocketError(
        "Failed to resolve UDP endpoint " + host + ":" +
            std::to_string(port),
        ec);
  }
 
  socket->open(asio::ip::udp::v4(), ec);
  if (ec)
  {
    ThrowSocketError("Failed to create UDP socket", ec);
  }
 
  asio::connect(*socket, endpoints, ec);
  if (ec)
  {
    ThrowSocketError(
        "Failed to connect UDP socket to " + host + ":" +
            std::to_string(port),
        ec);
  }
 
  SetTimeout(std::chrono::duration_cast<std::chrono::milliseconds>(timeout));
}
 
UdpSocket::UdpSocket(
    std::uint16_t localPort,
    std::chrono::duration<double> timeout)
    : ioContext(std::make_unique<asio::io_context>()),
      socket(std::make_unique<asio::ip::udp::socket>(*ioContext))
{
  asio::error_code ec;
 
  socket->open(asio::ip::udp::v4(), ec);
  if (ec)
  {
    ThrowSocketError("Failed to create UDP socket", ec);
  }
 
  socket->set_option(
      asio::ip::udp::socket::reuse_address(true),
      ec);
 
  if (ec)
  {
    ThrowSocketError("Failed to configure UDP socket reuse", ec);
  }
 
  const asio::ip::udp::endpoint endpoint(
      asio::ip::udp::v4(),
      localPort);
 
  socket->bind(endpoint, ec);
 
  if (ec)
  {
    ThrowSocketError(
        "Failed to bind UDP socket to port " +
            std::to_string(localPort),
        ec);
  }
 
  SetTimeout(std::chrono::duration_cast<std::chrono::milliseconds>(timeout));
}
 
UdpSocket::~UdpSocket()
{
  if (socket != nullptr)
  {
    asio::error_code ec;
    socket->cancel(ec);
    socket->close(ec);
  }
}
 
UdpSocket::UdpSocket(UdpSocket&& other) noexcept
    : ioContext(std::move(other.ioContext)),
      socket(std::move(other.socket)),
      receiveTimeout(other.receiveTimeout)
{
}
 
UdpSocket& UdpSocket::operator=(UdpSocket&& other) noexcept
{
  if (this != &other)
  {
    if (socket != nullptr)
    {
      asio::error_code ec;
      socket->cancel(ec);
      socket->close(ec);
    }
 
    ioContext = std::move(other.ioContext);
    socket = std::move(other.socket);
    receiveTimeout = other.receiveTimeout;
  }
 
  return *this;
}
 
void UdpSocket::Send(const std::vector<std::uint8_t>& data) const
{
  if (socket == nullptr || !socket->is_open())
  {
    throw SocketError("UDP socket is not open");
  }
 
  asio::error_code ec;
 
  const std::size_t sent = socket->send(
      asio::buffer(data),
      0,
      ec);
 
  if (ec)
  {
    ThrowSocketError("Failed to send UDP datagram", ec);
  }
 
  if (sent != data.size())
  {
    throw SocketError("UDP datagram was only partially sent");
  }
}
 
std::vector<std::uint8_t> UdpSocket::Recv(std::size_t maxLen) const
{
  if (socket == nullptr || !socket->is_open())
  {
    throw SocketError("UDP socket is not open");
  }
 
  if (maxLen == 0)
  {
    return {};
  }
 
  std::vector<std::uint8_t> buffer(maxLen);
 
  asio::error_code receiveError;
  std::size_t receivedBytes = 0;
  bool timedOut = false;
 
  asio::steady_timer timer(*ioContext);
  timer.expires_after(receiveTimeout);
 
  socket->async_receive(
      asio::buffer(buffer),
      [&](const asio::error_code& ec, std::size_t bytesReceived)
  {
    receiveError = ec;
    receivedBytes = bytesReceived;
 
    asio::error_code timerError;
    timer.cancel(timerError);
  });
 
  timer.async_wait(
      [&](const asio::error_code& ec)
  {
    if (ec)
    {
      return;
    }
 
    timedOut = true;
 
    asio::error_code cancelError;
    socket->cancel(cancelError);
  });
 
  ioContext->restart();
  ioContext->run();
 
  if (timedOut)
  {
    return {};
  }
 
  if (receiveError)
  {
    ThrowSocketError("Socket error during UDP receive", receiveError);
  }
 
  buffer.resize(receivedBytes);
  return buffer;
}
 
UdpDatagram UdpSocket::RecvFrom(std::size_t maxLen)
{
  if (socket == nullptr || !socket->is_open())
  {
    throw SocketError("UDP socket is not open");
  }
 
  if (maxLen == 0)
  {
    return {};
  }
 
  UdpDatagram datagram;
  datagram.data.resize(maxLen);
 
  asio::ip::udp::endpoint sourceEndpoint;
  asio::error_code receiveError;
  std::size_t receivedBytes = 0;
  bool timedOut = false;
 
  asio::steady_timer timer(*ioContext);
  timer.expires_after(receiveTimeout);
 
  socket->async_receive_from(
      asio::buffer(datagram.data),
      sourceEndpoint,
      [&](const asio::error_code& ec, std::size_t bytesReceived)
  {
    receiveError = ec;
    receivedBytes = bytesReceived;
 
    asio::error_code timerError;
    timer.cancel(timerError);
  });
 
  timer.async_wait(
      [&](const asio::error_code& ec)
  {
    if (ec)
    {
      return;
    }
 
    timedOut = true;
 
    asio::error_code cancelError;
    socket->cancel(cancelError);
  });
 
  ioContext->restart();
  ioContext->run();
 
  if (timedOut)
  {
    return {};
  }
 
  if (receiveError)
  {
    ThrowSocketError(
        "Socket error during UDP receive",
        receiveError);
  }
 
  datagram.data.resize(receivedBytes);
  datagram.source.address = sourceEndpoint.address().to_string();
  datagram.source.port = sourceEndpoint.port();
 
  return datagram;
}
 
void UdpSocket::SendTo(
    const std::vector<std::uint8_t>& data,
    const UdpEndpoint& destination)
{
  if (socket == nullptr || !socket->is_open())
  {
    throw SocketError("UDP socket is not open");
  }
 
  asio::error_code ec;
 
  const auto address =
      asio::ip::make_address_v4(destination.address, ec);
 
  if (ec)
  {
    throw SocketError(
        "Invalid IPv4 destination address '" +
        destination.address + "': " + ec.message());
  }
 
  const asio::ip::udp::endpoint endpoint(
      address,
      destination.port);
 
  const std::size_t sent = socket->send_to(
      asio::buffer(data),
      endpoint,
      0,
      ec);
 
  if (ec)
  {
    ThrowSocketError("Failed to send UDP datagram", ec);
  }
 
  if (sent != data.size())
  {
    throw SocketError("UDP datagram was only partially sent");
  }
}
 
void UdpSocket::SetTimeout(std::chrono::milliseconds timeout)
{
  receiveTimeout = std::max(timeout, std::chrono::milliseconds::zero());
}
 
UdpEndpoint UdpSocket::LocalEndpoint() const
{
  if (socket == nullptr || !socket->is_open())
  {
    throw SocketError("UDP socket is not open");
  }
 
  asio::error_code ec;
  const auto endpoint = socket->local_endpoint(ec);
 
  if (ec)
  {
    ThrowSocketError(
        "Failed to query local UDP endpoint",
        ec);
  }
 
  return {
      endpoint.address().to_string(),
      endpoint.port()};
}
 
} // namespace profinet