9#include <botan/internal/socket_udp.h>
11#include <botan/exceptn.h>
12#include <botan/mem_ops.h>
14#include <botan/internal/fmt.h>
15#include <botan/internal/stl_util.h>
16#include <botan/internal/target_info.h>
19#if defined(BOTAN_HAS_BOOST_ASIO)
25 #define BOOST_ASIO_DISABLE_SERIAL_PORT
26 #include <boost/asio.hpp>
27 #include <boost/asio/system_timer.hpp>
28#elif defined(BOTAN_TARGET_OS_HAS_SOCKETS)
32 #include <netinet/in.h>
34 #include <sys/socket.h>
38#elif defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
46#if defined(BOTAN_HAS_BOOST_ASIO)
47class Asio_SocketUDP final :
public OS::SocketUDP {
49 Asio_SocketUDP(std::string_view hostname, std::string_view service, std::chrono::microseconds timeout) :
50 m_timeout(timeout), m_timer(m_io), m_udp(m_io) {
51 m_timer.expires_after(m_timeout);
57 boost::asio::ip::udp::resolver resolver(m_io);
58 boost::asio::ip::udp::resolver::results_type dns_iter;
59 boost::system::error_code resolve_ec = boost::asio::error::would_block;
60 resolver.async_resolve(hostname, service, [&](
const boost::system::error_code& e,
auto results) {
62 dns_iter = std::move(results);
64 while(resolve_ec == boost::asio::error::would_block) {
65 if(m_timer.expiry() <
decltype(m_timer)::clock_type::now()) {
71 throw boost::system::system_error(resolve_ec);
74 boost::system::error_code ec = boost::asio::error::would_block;
76 auto connect_cb = [&ec](
const boost::system::error_code& e,
77 const boost::asio::ip::udp::resolver::results_type::iterator&) { ec = e; };
79 boost::asio::async_connect(m_udp, dns_iter.begin(), dns_iter.end(), connect_cb);
81 while(ec == boost::asio::error::would_block) {
86 throw boost::system::system_error(ec);
88 if(!m_udp.is_open()) {
89 throw System_Error(
fmt(
"Connection to host {} failed", hostname));
93 void write(
const uint8_t buf[],
size_t len)
override {
94 m_timer.expires_after(m_timeout);
96 boost::system::error_code ec = boost::asio::error::would_block;
98 m_udp.async_send(boost::asio::buffer(buf, len), [&ec](boost::system::error_code e,
size_t) { ec = e; });
100 while(ec == boost::asio::error::would_block) {
105 throw boost::system::system_error(ec);
109 size_t read(uint8_t buf[],
size_t len)
override {
110 m_timer.expires_after(m_timeout);
112 boost::system::error_code ec = boost::asio::error::would_block;
115 m_udp.async_receive(boost::asio::buffer(buf, len), [&](boost::system::error_code cb_ec,
size_t cb_got) {
120 while(ec == boost::asio::error::would_block) {
125 if(ec == boost::asio::error::eof) {
128 throw boost::system::system_error(ec);
135 void check_timeout() {
136 if(m_udp.is_open() && m_timer.expiry() <
decltype(m_timer)::clock_type::now()) {
137 boost::system::error_code err;
144 m_timer.async_wait(std::bind(&Asio_SocketUDP::check_timeout,
this));
147 const std::chrono::microseconds m_timeout;
148 boost::asio::io_context m_io;
149 boost::asio::system_timer m_timer;
150 boost::asio::ip::udp::socket m_udp;
152#elif defined(BOTAN_TARGET_OS_HAS_SOCKETS) || defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
153class BSD_SocketUDP final :
public OS::SocketUDP {
155 BSD_SocketUDP(std::string_view hostname, std::string_view service, std::chrono::microseconds timeout) :
156 m_timeout(timeout), m_socket(invalid_socket()) {
163 do_connect(hostname, service);
165 if(m_socket != invalid_socket()) {
166 close_socket(m_socket);
167 m_socket = invalid_socket();
175 void do_connect(std::string_view hostname, std::string_view service) {
176 const std::string hostname_str(hostname);
177 const std::string service_str(service);
180 hints.ai_family = AF_UNSPEC;
181 hints.ai_socktype = SOCK_DGRAM;
183 unique_addr_info_ptr res =
nullptr;
185 const int rc = ::getaddrinfo(hostname_str.c_str(), service_str.c_str(), &hints,
Botan::out_ptr(res));
187 throw System_Error(fmt(
"Name resolution failed for {}", hostname), rc);
190 for(
const addrinfo* rp = res.get(); (m_socket == invalid_socket()) && (rp !=
nullptr); rp = rp->ai_next) {
191 if(rp->ai_family != AF_INET && rp->ai_family != AF_INET6) {
195 m_socket = ::socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
197 if(m_socket == invalid_socket()) [[unlikely]] {
202 #if !defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
204 if(m_socket >= FD_SETSIZE) {
205 close_socket(m_socket);
206 m_socket = invalid_socket();
207 throw System_Error(
"Socket descriptor exceeds FD_SETSIZE; select() would be unsafe");
211 set_nonblocking(m_socket);
221 if(::connect(m_socket, rp->ai_addr,
static_cast<socklen_t
>(rp->ai_addrlen)) != 0) {
222 close_socket(m_socket);
223 m_socket = invalid_socket();
228 if(m_socket == invalid_socket()) {
230 fmt(
"Connecting to {} for service {} failed with errno {}", hostname, service, last_socket_error()),
231 last_socket_error());
236 ~BSD_SocketUDP()
override {
237 close_socket(m_socket);
238 m_socket = invalid_socket();
242 BSD_SocketUDP(
const BSD_SocketUDP& other) =
delete;
243 BSD_SocketUDP(BSD_SocketUDP&& other) =
delete;
244 BSD_SocketUDP& operator=(
const BSD_SocketUDP& other) =
delete;
245 BSD_SocketUDP& operator=(BSD_SocketUDP&& other) =
delete;
247 void write(
const uint8_t buf[],
size_t len)
override {
248 size_t sent_so_far = 0;
249 while(sent_so_far != len) {
252 FD_SET(m_socket, &write_set);
254 struct timeval timeout = make_timeout_tv();
255 const int active = ::select(
static_cast<int>(m_socket + 1),
nullptr, &write_set,
nullptr, &timeout);
258 if(last_error_is_retryable()) {
261 throw System_Error(
"Socket select failed", last_socket_error());
265 throw System_Error(
"Timeout during socket write");
268 const size_t left = len - sent_so_far;
269 const socket_op_ret_type sent =
270 ::send(m_socket, cast_uint8_ptr_to_char(buf + sent_so_far),
static_cast<sendrecv_len_type
>(left), 0);
272 if(last_error_is_retryable()) {
275 throw System_Error(
"Socket write failed", last_socket_error());
277 sent_so_far +=
static_cast<size_t>(sent);
282 size_t read(uint8_t buf[],
size_t len)
override {
286 FD_SET(m_socket, &read_set);
288 struct timeval timeout = make_timeout_tv();
289 const int active = ::select(
static_cast<int>(m_socket + 1), &read_set,
nullptr,
nullptr, &timeout);
292 if(last_error_is_retryable()) {
295 throw System_Error(
"Socket select failed", last_socket_error());
299 throw System_Error(
"Timeout during socket read");
304 const socket_op_ret_type got =
305 ::recv(m_socket, cast_uint8_ptr_to_char(buf),
static_cast<sendrecv_len_type
>(len), 0);
308 if(last_error_is_retryable()) {
311 throw System_Error(
"Socket read failed", last_socket_error());
314 return static_cast<size_t>(got);
319 #if defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
320 typedef SOCKET socket_type;
321 typedef int socket_op_ret_type;
322 typedef int sendrecv_len_type;
324 static socket_type invalid_socket() {
return INVALID_SOCKET; }
326 static void close_socket(socket_type s) { ::closesocket(s); }
328 static int last_socket_error() { return ::WSAGetLastError(); }
330 static std::string get_last_socket_error() {
return std::to_string(::WSAGetLastError()); }
332 static bool nonblocking_connect_in_progress() {
return (::WSAGetLastError() == WSAEWOULDBLOCK); }
334 static bool last_error_is_retryable() {
return (::WSAGetLastError() == WSAEINTR); }
336 static void set_nonblocking(socket_type s) {
337 u_long nonblocking = 1;
338 ::ioctlsocket(s, FIONBIO, &nonblocking);
341 static void socket_init() {
343 WORD wsa_version = MAKEWORD(2, 2);
345 if(::WSAStartup(wsa_version, &wsa_data) != 0) {
346 throw System_Error(
"WSAStartup() failed", WSAGetLastError());
349 if(LOBYTE(wsa_data.wVersion) != 2 || HIBYTE(wsa_data.wVersion) != 2) {
351 throw System_Error(
"Could not find a usable version of Winsock.dll");
355 static void socket_fini() { ::WSACleanup(); }
357 typedef int socket_type;
358 typedef ssize_t socket_op_ret_type;
359 typedef size_t sendrecv_len_type;
361 static socket_type invalid_socket() {
return -1; }
363 static void close_socket(socket_type s) { ::close(s); }
365 static int last_socket_error() {
return errno; }
367 static std::string get_last_socket_error() { return ::strerror(errno); }
369 static bool nonblocking_connect_in_progress() {
return (errno == EINPROGRESS); }
371 static bool last_error_is_retryable() {
return (errno == EINTR); }
373 static void set_nonblocking(socket_type s) {
375 if(::fcntl(s, F_SETFL, O_NONBLOCK) < 0) {
376 throw System_Error(
"Setting socket to non-blocking state failed", errno);
380 static void socket_init() {}
382 static void socket_fini() {}
384 struct timeval make_timeout_tv() const {
385 struct timeval tv {};
387 tv.tv_sec =
static_cast<decltype(timeval::tv_sec)
>(m_timeout.count() / 1000000);
388 tv.tv_usec =
static_cast<decltype(timeval::tv_usec)
>(m_timeout.count() % 1000000);
392 const std::chrono::microseconds m_timeout;
393 socket_type m_socket;
395 using unique_addr_info_ptr = std::unique_ptr<addrinfo,
decltype([](addrinfo* p) {
405 std::string_view service,
406 std::chrono::microseconds timeout) {
407#if defined(BOTAN_HAS_BOOST_ASIO)
408 return std::make_unique<Asio_SocketUDP>(hostname, service, timeout);
409#elif defined(BOTAN_TARGET_OS_HAS_SOCKETS) || defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
410 return std::make_unique<BSD_SocketUDP>(hostname, service, timeout);
415 return std::unique_ptr<OS::SocketUDP>();
419std::unique_ptr<OS::SocketUDP>
OS::open_socket_udp(std::string_view uri_string, std::chrono::microseconds timeout) {
421 if(!authority.has_value() || !authority->port().has_value()) {
424 return open_socket_udp(authority->host_to_string(), std::to_string(*authority->port()), timeout);
static std::optional< Authority > from_string(std::string_view raw)
std::unique_ptr< SocketUDP > BOTAN_TEST_API open_socket_udp(std::string_view hostname, std::string_view service, std::chrono::microseconds timeout)
constexpr auto out_ptr(T &outptr) noexcept
std::string fmt(std::string_view format, const T &... args)