1//
2// detail/impl/socket_ops.ipp
3// ~~~~~~~~~~~~~~~~~~~~~~~~~~
4//
5// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6//
7// Distributed under the Boost Software License, Version 1.0. (See accompanying
8// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9//
10
11#ifndef BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
12#define BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
13
14#if defined(_MSC_VER) && (_MSC_VER >= 1200)
15# pragma once
16#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
17
18#include <boost/asio/detail/config.hpp>
19
20#include <cctype>
21#include <cstdio>
22#include <cstdlib>
23#include <cstring>
24#include <cerrno>
25#include <new>
26#include <boost/asio/detail/assert.hpp>
27#include <boost/asio/detail/socket_ops.hpp>
28#include <boost/asio/error.hpp>
29
30#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
31# include <codecvt>
32# include <locale>
33# include <string>
34#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
35
36#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) \
37 || defined(__MACH__) && defined(__APPLE__)
38# if defined(BOOST_ASIO_HAS_PTHREADS)
39# include <pthread.h>
40# endif // defined(BOOST_ASIO_HAS_PTHREADS)
41#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
42 // || defined(__MACH__) && defined(__APPLE__)
43
44#include <boost/asio/detail/push_options.hpp>
45
46namespace boost {
47namespace asio {
48namespace detail {
49namespace socket_ops {
50
51#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
52
53#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
54struct msghdr { int msg_namelen; };
55#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
56
57#if defined(__hpux)
58// HP-UX doesn't declare these functions extern "C", so they are declared again
59// here to avoid linker errors about undefined symbols.
60extern "C" char* if_indextoname(unsigned int, char*);
61extern "C" unsigned int if_nametoindex(const char*);
62#endif // defined(__hpux)
63
64#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
65
66inline void clear_last_error()
67{
68#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
69 WSASetLastError(0);
70#else
71 errno = 0;
72#endif
73}
74
75#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
76
77template <typename ReturnType>
78inline ReturnType error_wrapper(ReturnType return_value,
79 boost::system::error_code& ec)
80{
81#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
82 ec = boost::system::error_code(WSAGetLastError(),
83 boost::asio::error::get_system_category());
84#else
85 ec = boost::system::error_code(errno,
86 boost::asio::error::get_system_category());
87#endif
88 return return_value;
89}
90
91template <typename SockLenType>
92inline socket_type call_accept(SockLenType msghdr::*,
93 socket_type s, socket_addr_type* addr, std::size_t* addrlen)
94{
95 SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
96 socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0);
97 if (addrlen)
98 *addrlen = (std::size_t)tmp_addrlen;
99 return result;
100}
101
102socket_type accept(socket_type s, socket_addr_type* addr,
103 std::size_t* addrlen, boost::system::error_code& ec)
104{
105 if (s == invalid_socket)
106 {
107 ec = boost::asio::error::bad_descriptor;
108 return invalid_socket;
109 }
110
111 clear_last_error();
112
113 socket_type new_s = error_wrapper(call_accept(
114 &msghdr::msg_namelen, s, addr, addrlen), ec);
115 if (new_s == invalid_socket)
116 return new_s;
117
118#if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
119 int optval = 1;
120 int result = error_wrapper(::setsockopt(new_s,
121 SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)), ec);
122 if (result != 0)
123 {
124 ::close(new_s);
125 return invalid_socket;
126 }
127#endif
128
129 ec = boost::system::error_code();
130 return new_s;
131}
132
133socket_type sync_accept(socket_type s, state_type state,
134 socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
135{
136 // Accept a socket.
137 for (;;)
138 {
139 // Try to complete the operation without blocking.
140 socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
141
142 // Check if operation succeeded.
143 if (new_socket != invalid_socket)
144 return new_socket;
145
146 // Operation failed.
147 if (ec == boost::asio::error::would_block
148 || ec == boost::asio::error::try_again)
149 {
150 if (state & user_set_non_blocking)
151 return invalid_socket;
152 // Fall through to retry operation.
153 }
154 else if (ec == boost::asio::error::connection_aborted)
155 {
156 if (state & enable_connection_aborted)
157 return invalid_socket;
158 // Fall through to retry operation.
159 }
160#if defined(EPROTO)
161 else if (ec.value() == EPROTO)
162 {
163 if (state & enable_connection_aborted)
164 return invalid_socket;
165 // Fall through to retry operation.
166 }
167#endif // defined(EPROTO)
168 else
169 return invalid_socket;
170
171 // Wait for socket to become ready.
172 if (socket_ops::poll_read(s, 0, ec) < 0)
173 return invalid_socket;
174 }
175}
176
177#if defined(BOOST_ASIO_HAS_IOCP)
178
179void complete_iocp_accept(socket_type s,
180 void* output_buffer, DWORD address_length,
181 socket_addr_type* addr, std::size_t* addrlen,
182 socket_type new_socket, boost::system::error_code& ec)
183{
184 // Map non-portable errors to their portable counterparts.
185 if (ec.value() == ERROR_NETNAME_DELETED)
186 ec = boost::asio::error::connection_aborted;
187
188 if (!ec)
189 {
190 // Get the address of the peer.
191 if (addr && addrlen)
192 {
193 LPSOCKADDR local_addr = 0;
194 int local_addr_length = 0;
195 LPSOCKADDR remote_addr = 0;
196 int remote_addr_length = 0;
197 GetAcceptExSockaddrs(output_buffer, 0, address_length,
198 address_length, &local_addr, &local_addr_length,
199 &remote_addr, &remote_addr_length);
200 if (static_cast<std::size_t>(remote_addr_length) > *addrlen)
201 {
202 ec = boost::asio::error::invalid_argument;
203 }
204 else
205 {
206 using namespace std; // For memcpy.
207 memcpy(addr, remote_addr, remote_addr_length);
208 *addrlen = static_cast<std::size_t>(remote_addr_length);
209 }
210 }
211
212 // Need to set the SO_UPDATE_ACCEPT_CONTEXT option so that getsockname
213 // and getpeername will work on the accepted socket.
214 SOCKET update_ctx_param = s;
215 socket_ops::state_type state = 0;
216 socket_ops::setsockopt(new_socket, state,
217 SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
218 &update_ctx_param, sizeof(SOCKET), ec);
219 }
220}
221
222#else // defined(BOOST_ASIO_HAS_IOCP)
223
224bool non_blocking_accept(socket_type s,
225 state_type state, socket_addr_type* addr, std::size_t* addrlen,
226 boost::system::error_code& ec, socket_type& new_socket)
227{
228 for (;;)
229 {
230 // Accept the waiting connection.
231 new_socket = socket_ops::accept(s, addr, addrlen, ec);
232
233 // Check if operation succeeded.
234 if (new_socket != invalid_socket)
235 return true;
236
237 // Retry operation if interrupted by signal.
238 if (ec == boost::asio::error::interrupted)
239 continue;
240
241 // Operation failed.
242 if (ec == boost::asio::error::would_block
243 || ec == boost::asio::error::try_again)
244 {
245 if (state & user_set_non_blocking)
246 return true;
247 // Fall through to retry operation.
248 }
249 else if (ec == boost::asio::error::connection_aborted)
250 {
251 if (state & enable_connection_aborted)
252 return true;
253 // Fall through to retry operation.
254 }
255#if defined(EPROTO)
256 else if (ec.value() == EPROTO)
257 {
258 if (state & enable_connection_aborted)
259 return true;
260 // Fall through to retry operation.
261 }
262#endif // defined(EPROTO)
263 else
264 return true;
265
266 return false;
267 }
268}
269
270#endif // defined(BOOST_ASIO_HAS_IOCP)
271
272template <typename SockLenType>
273inline int call_bind(SockLenType msghdr::*,
274 socket_type s, const socket_addr_type* addr, std::size_t addrlen)
275{
276 return ::bind(s, addr, (SockLenType)addrlen);
277}
278
279int bind(socket_type s, const socket_addr_type* addr,
280 std::size_t addrlen, boost::system::error_code& ec)
281{
282 if (s == invalid_socket)
283 {
284 ec = boost::asio::error::bad_descriptor;
285 return socket_error_retval;
286 }
287
288 clear_last_error();
289 int result = error_wrapper(call_bind(
290 &msghdr::msg_namelen, s, addr, addrlen), ec);
291 if (result == 0)
292 ec = boost::system::error_code();
293 return result;
294}
295
296int close(socket_type s, state_type& state,
297 bool destruction, boost::system::error_code& ec)
298{
299 int result = 0;
300 if (s != invalid_socket)
301 {
302 // We don't want the destructor to block, so set the socket to linger in
303 // the background. If the user doesn't like this behaviour then they need
304 // to explicitly close the socket.
305 if (destruction && (state & user_set_linger))
306 {
307 ::linger opt;
308 opt.l_onoff = 0;
309 opt.l_linger = 0;
310 boost::system::error_code ignored_ec;
311 socket_ops::setsockopt(s, state, SOL_SOCKET,
312 SO_LINGER, &opt, sizeof(opt), ignored_ec);
313 }
314
315 clear_last_error();
316#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
317 result = error_wrapper(::closesocket(s), ec);
318#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
319 result = error_wrapper(::close(s), ec);
320#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
321
322 if (result != 0
323 && (ec == boost::asio::error::would_block
324 || ec == boost::asio::error::try_again))
325 {
326 // According to UNIX Network Programming Vol. 1, it is possible for
327 // close() to fail with EWOULDBLOCK under certain circumstances. What
328 // isn't clear is the state of the descriptor after this error. The one
329 // current OS where this behaviour is seen, Windows, says that the socket
330 // remains open. Therefore we'll put the descriptor back into blocking
331 // mode and have another attempt at closing it.
332#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
333 ioctl_arg_type arg = 0;
334 ::ioctlsocket(s, FIONBIO, &arg);
335#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
336# if defined(__SYMBIAN32__)
337 int flags = ::fcntl(s, F_GETFL, 0);
338 if (flags >= 0)
339 ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
340# else // defined(__SYMBIAN32__)
341 ioctl_arg_type arg = 0;
342 ::ioctl(s, FIONBIO, &arg);
343# endif // defined(__SYMBIAN32__)
344#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
345 state &= ~non_blocking;
346
347 clear_last_error();
348#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
349 result = error_wrapper(::closesocket(s), ec);
350#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
351 result = error_wrapper(::close(s), ec);
352#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
353 }
354 }
355
356 if (result == 0)
357 ec = boost::system::error_code();
358 return result;
359}
360
361bool set_user_non_blocking(socket_type s,
362 state_type& state, bool value, boost::system::error_code& ec)
363{
364 if (s == invalid_socket)
365 {
366 ec = boost::asio::error::bad_descriptor;
367 return false;
368 }
369
370 clear_last_error();
371#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
372 ioctl_arg_type arg = (value ? 1 : 0);
373 int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
374#elif defined(__SYMBIAN32__)
375 int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
376 if (result >= 0)
377 {
378 clear_last_error();
379 int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
380 result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
381 }
382#else
383 ioctl_arg_type arg = (value ? 1 : 0);
384 int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
385#endif
386
387 if (result >= 0)
388 {
389 ec = boost::system::error_code();
390 if (value)
391 state |= user_set_non_blocking;
392 else
393 {
394 // Clearing the user-set non-blocking mode always overrides any
395 // internally-set non-blocking flag. Any subsequent asynchronous
396 // operations will need to re-enable non-blocking I/O.
397 state &= ~(user_set_non_blocking | internal_non_blocking);
398 }
399 return true;
400 }
401
402 return false;
403}
404
405bool set_internal_non_blocking(socket_type s,
406 state_type& state, bool value, boost::system::error_code& ec)
407{
408 if (s == invalid_socket)
409 {
410 ec = boost::asio::error::bad_descriptor;
411 return false;
412 }
413
414 if (!value && (state & user_set_non_blocking))
415 {
416 // It does not make sense to clear the internal non-blocking flag if the
417 // user still wants non-blocking behaviour. Return an error and let the
418 // caller figure out whether to update the user-set non-blocking flag.
419 ec = boost::asio::error::invalid_argument;
420 return false;
421 }
422
423 clear_last_error();
424#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
425 ioctl_arg_type arg = (value ? 1 : 0);
426 int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
427#elif defined(__SYMBIAN32__)
428 int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
429 if (result >= 0)
430 {
431 clear_last_error();
432 int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
433 result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
434 }
435#else
436 ioctl_arg_type arg = (value ? 1 : 0);
437 int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
438#endif
439
440 if (result >= 0)
441 {
442 ec = boost::system::error_code();
443 if (value)
444 state |= internal_non_blocking;
445 else
446 state &= ~internal_non_blocking;
447 return true;
448 }
449
450 return false;
451}
452
453int shutdown(socket_type s, int what, boost::system::error_code& ec)
454{
455 if (s == invalid_socket)
456 {
457 ec = boost::asio::error::bad_descriptor;
458 return socket_error_retval;
459 }
460
461 clear_last_error();
462 int result = error_wrapper(::shutdown(s, what), ec);
463 if (result == 0)
464 ec = boost::system::error_code();
465 return result;
466}
467
468template <typename SockLenType>
469inline int call_connect(SockLenType msghdr::*,
470 socket_type s, const socket_addr_type* addr, std::size_t addrlen)
471{
472 return ::connect(s, addr, (SockLenType)addrlen);
473}
474
475int connect(socket_type s, const socket_addr_type* addr,
476 std::size_t addrlen, boost::system::error_code& ec)
477{
478 if (s == invalid_socket)
479 {
480 ec = boost::asio::error::bad_descriptor;
481 return socket_error_retval;
482 }
483
484 clear_last_error();
485 int result = error_wrapper(call_connect(
486 &msghdr::msg_namelen, s, addr, addrlen), ec);
487 if (result == 0)
488 ec = boost::system::error_code();
489#if defined(__linux__)
490 else if (ec == boost::asio::error::try_again)
491 ec = boost::asio::error::no_buffer_space;
492#endif // defined(__linux__)
493 return result;
494}
495
496void sync_connect(socket_type s, const socket_addr_type* addr,
497 std::size_t addrlen, boost::system::error_code& ec)
498{
499 // Perform the connect operation.
500 socket_ops::connect(s, addr, addrlen, ec);
501 if (ec != boost::asio::error::in_progress
502 && ec != boost::asio::error::would_block)
503 {
504 // The connect operation finished immediately.
505 return;
506 }
507
508 // Wait for socket to become ready.
509 if (socket_ops::poll_connect(s, ec) < 0)
510 return;
511
512 // Get the error code from the connect operation.
513 int connect_error = 0;
514 size_t connect_error_len = sizeof(connect_error);
515 if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
516 &connect_error, &connect_error_len, ec) == socket_error_retval)
517 return;
518
519 // Return the result of the connect operation.
520 ec = boost::system::error_code(connect_error,
521 boost::asio::error::get_system_category());
522}
523
524#if defined(BOOST_ASIO_HAS_IOCP)
525
526void complete_iocp_connect(socket_type s, boost::system::error_code& ec)
527{
528 // Map non-portable errors to their portable counterparts.
529 switch (ec.value())
530 {
531 case ERROR_CONNECTION_REFUSED:
532 ec = boost::asio::error::connection_refused;
533 break;
534 case ERROR_NETWORK_UNREACHABLE:
535 ec = boost::asio::error::network_unreachable;
536 break;
537 case ERROR_HOST_UNREACHABLE:
538 ec = boost::asio::error::host_unreachable;
539 break;
540 case ERROR_SEM_TIMEOUT:
541 ec = boost::asio::error::timed_out;
542 break;
543 default:
544 break;
545 }
546
547 if (!ec)
548 {
549 // Need to set the SO_UPDATE_CONNECT_CONTEXT option so that getsockname
550 // and getpeername will work on the connected socket.
551 socket_ops::state_type state = 0;
552 const int so_update_connect_context = 0x7010;
553 socket_ops::setsockopt(s, state, SOL_SOCKET,
554 so_update_connect_context, 0, 0, ec);
555 }
556}
557
558#endif // defined(BOOST_ASIO_HAS_IOCP)
559
560bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
561{
562 // Check if the connect operation has finished. This is required since we may
563 // get spurious readiness notifications from the reactor.
564#if defined(BOOST_ASIO_WINDOWS) \
565 || defined(__CYGWIN__) \
566 || defined(__SYMBIAN32__)
567 fd_set write_fds;
568 FD_ZERO(&write_fds);
569 FD_SET(s, &write_fds);
570 fd_set except_fds;
571 FD_ZERO(&except_fds);
572 FD_SET(s, &except_fds);
573 timeval zero_timeout;
574 zero_timeout.tv_sec = 0;
575 zero_timeout.tv_usec = 0;
576 int ready = ::select(s + 1, 0, &write_fds, &except_fds, &zero_timeout);
577#else // defined(BOOST_ASIO_WINDOWS)
578 // || defined(__CYGWIN__)
579 // || defined(__SYMBIAN32__)
580 pollfd fds;
581 fds.fd = s;
582 fds.events = POLLOUT;
583 fds.revents = 0;
584 int ready = ::poll(&fds, 1, 0);
585#endif // defined(BOOST_ASIO_WINDOWS)
586 // || defined(__CYGWIN__)
587 // || defined(__SYMBIAN32__)
588 if (ready == 0)
589 {
590 // The asynchronous connect operation is still in progress.
591 return false;
592 }
593
594 // Get the error code from the connect operation.
595 int connect_error = 0;
596 size_t connect_error_len = sizeof(connect_error);
597 if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
598 &connect_error, &connect_error_len, ec) == 0)
599 {
600 if (connect_error)
601 {
602 ec = boost::system::error_code(connect_error,
603 boost::asio::error::get_system_category());
604 }
605 else
606 ec = boost::system::error_code();
607 }
608
609 return true;
610}
611
612int socketpair(int af, int type, int protocol,
613 socket_type sv[2], boost::system::error_code& ec)
614{
615#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
616 (void)(af);
617 (void)(type);
618 (void)(protocol);
619 (void)(sv);
620 ec = boost::asio::error::operation_not_supported;
621 return socket_error_retval;
622#else
623 clear_last_error();
624 int result = error_wrapper(::socketpair(af, type, protocol, sv), ec);
625 if (result == 0)
626 ec = boost::system::error_code();
627 return result;
628#endif
629}
630
631bool sockatmark(socket_type s, boost::system::error_code& ec)
632{
633 if (s == invalid_socket)
634 {
635 ec = boost::asio::error::bad_descriptor;
636 return false;
637 }
638
639#if defined(SIOCATMARK)
640 ioctl_arg_type value = 0;
641# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
642 int result = error_wrapper(::ioctlsocket(s, SIOCATMARK, &value), ec);
643# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
644 int result = error_wrapper(::ioctl(s, SIOCATMARK, &value), ec);
645# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
646 if (result == 0)
647 ec = boost::system::error_code();
648# if defined(ENOTTY)
649 if (ec.value() == ENOTTY)
650 ec = boost::asio::error::not_socket;
651# endif // defined(ENOTTY)
652#else // defined(SIOCATMARK)
653 int value = error_wrapper(::sockatmark(s), ec);
654 if (value != -1)
655 ec = boost::system::error_code();
656#endif // defined(SIOCATMARK)
657
658 return ec ? false : value != 0;
659}
660
661size_t available(socket_type s, boost::system::error_code& ec)
662{
663 if (s == invalid_socket)
664 {
665 ec = boost::asio::error::bad_descriptor;
666 return 0;
667 }
668
669 ioctl_arg_type value = 0;
670#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
671 int result = error_wrapper(::ioctlsocket(s, FIONREAD, &value), ec);
672#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
673 int result = error_wrapper(::ioctl(s, FIONREAD, &value), ec);
674#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
675 if (result == 0)
676 ec = boost::system::error_code();
677#if defined(ENOTTY)
678 if (ec.value() == ENOTTY)
679 ec = boost::asio::error::not_socket;
680#endif // defined(ENOTTY)
681
682 return ec ? static_cast<size_t>(0) : static_cast<size_t>(value);
683}
684
685int listen(socket_type s, int backlog, boost::system::error_code& ec)
686{
687 if (s == invalid_socket)
688 {
689 ec = boost::asio::error::bad_descriptor;
690 return socket_error_retval;
691 }
692
693 clear_last_error();
694 int result = error_wrapper(::listen(s, backlog), ec);
695 if (result == 0)
696 ec = boost::system::error_code();
697 return result;
698}
699
700inline void init_buf_iov_base(void*& base, void* addr)
701{
702 base = addr;
703}
704
705template <typename T>
706inline void init_buf_iov_base(T& base, void* addr)
707{
708 base = static_cast<T>(addr);
709}
710
711#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
712typedef WSABUF buf;
713#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
714typedef iovec buf;
715#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
716
717void init_buf(buf& b, void* data, size_t size)
718{
719#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
720 b.buf = static_cast<char*>(data);
721 b.len = static_cast<u_long>(size);
722#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
723 init_buf_iov_base(b.iov_base, data);
724 b.iov_len = size;
725#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
726}
727
728void init_buf(buf& b, const void* data, size_t size)
729{
730#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
731 b.buf = static_cast<char*>(const_cast<void*>(data));
732 b.len = static_cast<u_long>(size);
733#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
734 init_buf_iov_base(b.iov_base, const_cast<void*>(data));
735 b.iov_len = size;
736#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
737}
738
739inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
740{
741 name = addr;
742}
743
744inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
745{
746 name = const_cast<socket_addr_type*>(addr);
747}
748
749template <typename T>
750inline void init_msghdr_msg_name(T& name, socket_addr_type* addr)
751{
752 name = reinterpret_cast<T>(addr);
753}
754
755template <typename T>
756inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
757{
758 name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
759}
760
761signed_size_type recv(socket_type s, buf* bufs, size_t count,
762 int flags, boost::system::error_code& ec)
763{
764 clear_last_error();
765#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
766 // Receive some data.
767 DWORD recv_buf_count = static_cast<DWORD>(count);
768 DWORD bytes_transferred = 0;
769 DWORD recv_flags = flags;
770 int result = error_wrapper(::WSARecv(s, bufs,
771 recv_buf_count, &bytes_transferred, &recv_flags, 0, 0), ec);
772 if (ec.value() == ERROR_NETNAME_DELETED)
773 ec = boost::asio::error::connection_reset;
774 else if (ec.value() == ERROR_PORT_UNREACHABLE)
775 ec = boost::asio::error::connection_refused;
776 if (result != 0)
777 return socket_error_retval;
778 ec = boost::system::error_code();
779 return bytes_transferred;
780#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
781 msghdr msg = msghdr();
782 msg.msg_iov = bufs;
783 msg.msg_iovlen = static_cast<int>(count);
784 signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
785 if (result >= 0)
786 ec = boost::system::error_code();
787 return result;
788#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
789}
790
791size_t sync_recv(socket_type s, state_type state, buf* bufs,
792 size_t count, int flags, bool all_empty, boost::system::error_code& ec)
793{
794 if (s == invalid_socket)
795 {
796 ec = boost::asio::error::bad_descriptor;
797 return 0;
798 }
799
800 // A request to read 0 bytes on a stream is a no-op.
801 if (all_empty && (state & stream_oriented))
802 {
803 ec = boost::system::error_code();
804 return 0;
805 }
806
807 // Read some data.
808 for (;;)
809 {
810 // Try to complete the operation without blocking.
811 signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
812
813 // Check if operation succeeded.
814 if (bytes > 0)
815 return bytes;
816
817 // Check for EOF.
818 if ((state & stream_oriented) && bytes == 0)
819 {
820 ec = boost::asio::error::eof;
821 return 0;
822 }
823
824 // Operation failed.
825 if ((state & user_set_non_blocking)
826 || (ec != boost::asio::error::would_block
827 && ec != boost::asio::error::try_again))
828 return 0;
829
830 // Wait for socket to become ready.
831 if (socket_ops::poll_read(s, 0, ec) < 0)
832 return 0;
833 }
834}
835
836#if defined(BOOST_ASIO_HAS_IOCP)
837
838void complete_iocp_recv(state_type state,
839 const weak_cancel_token_type& cancel_token, bool all_empty,
840 boost::system::error_code& ec, size_t bytes_transferred)
841{
842 // Map non-portable errors to their portable counterparts.
843 if (ec.value() == ERROR_NETNAME_DELETED)
844 {
845 if (cancel_token.expired())
846 ec = boost::asio::error::operation_aborted;
847 else
848 ec = boost::asio::error::connection_reset;
849 }
850 else if (ec.value() == ERROR_PORT_UNREACHABLE)
851 {
852 ec = boost::asio::error::connection_refused;
853 }
854
855 // Check for connection closed.
856 else if (!ec && bytes_transferred == 0
857 && (state & stream_oriented) != 0
858 && !all_empty)
859 {
860 ec = boost::asio::error::eof;
861 }
862}
863
864#else // defined(BOOST_ASIO_HAS_IOCP)
865
866bool non_blocking_recv(socket_type s,
867 buf* bufs, size_t count, int flags, bool is_stream,
868 boost::system::error_code& ec, size_t& bytes_transferred)
869{
870 for (;;)
871 {
872 // Read some data.
873 signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
874
875 // Check for end of stream.
876 if (is_stream && bytes == 0)
877 {
878 ec = boost::asio::error::eof;
879 return true;
880 }
881
882 // Retry operation if interrupted by signal.
883 if (ec == boost::asio::error::interrupted)
884 continue;
885
886 // Check if we need to run the operation again.
887 if (ec == boost::asio::error::would_block
888 || ec == boost::asio::error::try_again)
889 return false;
890
891 // Operation is complete.
892 if (bytes >= 0)
893 {
894 ec = boost::system::error_code();
895 bytes_transferred = bytes;
896 }
897 else
898 bytes_transferred = 0;
899
900 return true;
901 }
902}
903
904#endif // defined(BOOST_ASIO_HAS_IOCP)
905
906signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
907 int flags, socket_addr_type* addr, std::size_t* addrlen,
908 boost::system::error_code& ec)
909{
910 clear_last_error();
911#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
912 // Receive some data.
913 DWORD recv_buf_count = static_cast<DWORD>(count);
914 DWORD bytes_transferred = 0;
915 DWORD recv_flags = flags;
916 int tmp_addrlen = (int)*addrlen;
917 int result = error_wrapper(::WSARecvFrom(s, bufs, recv_buf_count,
918 &bytes_transferred, &recv_flags, addr, &tmp_addrlen, 0, 0), ec);
919 *addrlen = (std::size_t)tmp_addrlen;
920 if (ec.value() == ERROR_NETNAME_DELETED)
921 ec = boost::asio::error::connection_reset;
922 else if (ec.value() == ERROR_PORT_UNREACHABLE)
923 ec = boost::asio::error::connection_refused;
924 if (result != 0)
925 return socket_error_retval;
926 ec = boost::system::error_code();
927 return bytes_transferred;
928#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
929 msghdr msg = msghdr();
930 init_msghdr_msg_name(msg.msg_name, addr);
931 msg.msg_namelen = static_cast<int>(*addrlen);
932 msg.msg_iov = bufs;
933 msg.msg_iovlen = static_cast<int>(count);
934 signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
935 *addrlen = msg.msg_namelen;
936 if (result >= 0)
937 ec = boost::system::error_code();
938 return result;
939#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
940}
941
942size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
943 size_t count, int flags, socket_addr_type* addr,
944 std::size_t* addrlen, boost::system::error_code& ec)
945{
946 if (s == invalid_socket)
947 {
948 ec = boost::asio::error::bad_descriptor;
949 return 0;
950 }
951
952 // Read some data.
953 for (;;)
954 {
955 // Try to complete the operation without blocking.
956 signed_size_type bytes = socket_ops::recvfrom(
957 s, bufs, count, flags, addr, addrlen, ec);
958
959 // Check if operation succeeded.
960 if (bytes >= 0)
961 return bytes;
962
963 // Operation failed.
964 if ((state & user_set_non_blocking)
965 || (ec != boost::asio::error::would_block
966 && ec != boost::asio::error::try_again))
967 return 0;
968
969 // Wait for socket to become ready.
970 if (socket_ops::poll_read(s, 0, ec) < 0)
971 return 0;
972 }
973}
974
975#if defined(BOOST_ASIO_HAS_IOCP)
976
977void complete_iocp_recvfrom(
978 const weak_cancel_token_type& cancel_token,
979 boost::system::error_code& ec)
980{
981 // Map non-portable errors to their portable counterparts.
982 if (ec.value() == ERROR_NETNAME_DELETED)
983 {
984 if (cancel_token.expired())
985 ec = boost::asio::error::operation_aborted;
986 else
987 ec = boost::asio::error::connection_reset;
988 }
989 else if (ec.value() == ERROR_PORT_UNREACHABLE)
990 {
991 ec = boost::asio::error::connection_refused;
992 }
993}
994
995#else // defined(BOOST_ASIO_HAS_IOCP)
996
997bool non_blocking_recvfrom(socket_type s,
998 buf* bufs, size_t count, int flags,
999 socket_addr_type* addr, std::size_t* addrlen,
1000 boost::system::error_code& ec, size_t& bytes_transferred)
1001{
1002 for (;;)
1003 {
1004 // Read some data.
1005 signed_size_type bytes = socket_ops::recvfrom(
1006 s, bufs, count, flags, addr, addrlen, ec);
1007
1008 // Retry operation if interrupted by signal.
1009 if (ec == boost::asio::error::interrupted)
1010 continue;
1011
1012 // Check if we need to run the operation again.
1013 if (ec == boost::asio::error::would_block
1014 || ec == boost::asio::error::try_again)
1015 return false;
1016
1017 // Operation is complete.
1018 if (bytes >= 0)
1019 {
1020 ec = boost::system::error_code();
1021 bytes_transferred = bytes;
1022 }
1023 else
1024 bytes_transferred = 0;
1025
1026 return true;
1027 }
1028}
1029
1030#endif // defined(BOOST_ASIO_HAS_IOCP)
1031
1032signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
1033 int in_flags, int& out_flags, boost::system::error_code& ec)
1034{
1035 clear_last_error();
1036#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1037 out_flags = 0;
1038 return socket_ops::recv(s, bufs, count, in_flags, ec);
1039#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1040 msghdr msg = msghdr();
1041 msg.msg_iov = bufs;
1042 msg.msg_iovlen = static_cast<int>(count);
1043 signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
1044 if (result >= 0)
1045 {
1046 ec = boost::system::error_code();
1047 out_flags = msg.msg_flags;
1048 }
1049 else
1050 out_flags = 0;
1051 return result;
1052#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1053}
1054
1055size_t sync_recvmsg(socket_type s, state_type state,
1056 buf* bufs, size_t count, int in_flags, int& out_flags,
1057 boost::system::error_code& ec)
1058{
1059 if (s == invalid_socket)
1060 {
1061 ec = boost::asio::error::bad_descriptor;
1062 return 0;
1063 }
1064
1065 // Read some data.
1066 for (;;)
1067 {
1068 // Try to complete the operation without blocking.
1069 signed_size_type bytes = socket_ops::recvmsg(
1070 s, bufs, count, in_flags, out_flags, ec);
1071
1072 // Check if operation succeeded.
1073 if (bytes >= 0)
1074 return bytes;
1075
1076 // Operation failed.
1077 if ((state & user_set_non_blocking)
1078 || (ec != boost::asio::error::would_block
1079 && ec != boost::asio::error::try_again))
1080 return 0;
1081
1082 // Wait for socket to become ready.
1083 if (socket_ops::poll_read(s, 0, ec) < 0)
1084 return 0;
1085 }
1086}
1087
1088#if defined(BOOST_ASIO_HAS_IOCP)
1089
1090void complete_iocp_recvmsg(
1091 const weak_cancel_token_type& cancel_token,
1092 boost::system::error_code& ec)
1093{
1094 // Map non-portable errors to their portable counterparts.
1095 if (ec.value() == ERROR_NETNAME_DELETED)
1096 {
1097 if (cancel_token.expired())
1098 ec = boost::asio::error::operation_aborted;
1099 else
1100 ec = boost::asio::error::connection_reset;
1101 }
1102 else if (ec.value() == ERROR_PORT_UNREACHABLE)
1103 {
1104 ec = boost::asio::error::connection_refused;
1105 }
1106}
1107
1108#else // defined(BOOST_ASIO_HAS_IOCP)
1109
1110bool non_blocking_recvmsg(socket_type s,
1111 buf* bufs, size_t count, int in_flags, int& out_flags,
1112 boost::system::error_code& ec, size_t& bytes_transferred)
1113{
1114 for (;;)
1115 {
1116 // Read some data.
1117 signed_size_type bytes = socket_ops::recvmsg(
1118 s, bufs, count, in_flags, out_flags, ec);
1119
1120 // Retry operation if interrupted by signal.
1121 if (ec == boost::asio::error::interrupted)
1122 continue;
1123
1124 // Check if we need to run the operation again.
1125 if (ec == boost::asio::error::would_block
1126 || ec == boost::asio::error::try_again)
1127 return false;
1128
1129 // Operation is complete.
1130 if (bytes >= 0)
1131 {
1132 ec = boost::system::error_code();
1133 bytes_transferred = bytes;
1134 }
1135 else
1136 bytes_transferred = 0;
1137
1138 return true;
1139 }
1140}
1141
1142#endif // defined(BOOST_ASIO_HAS_IOCP)
1143
1144signed_size_type send(socket_type s, const buf* bufs, size_t count,
1145 int flags, boost::system::error_code& ec)
1146{
1147 clear_last_error();
1148#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1149 // Send the data.
1150 DWORD send_buf_count = static_cast<DWORD>(count);
1151 DWORD bytes_transferred = 0;
1152 DWORD send_flags = flags;
1153 int result = error_wrapper(::WSASend(s, const_cast<buf*>(bufs),
1154 send_buf_count, &bytes_transferred, send_flags, 0, 0), ec);
1155 if (ec.value() == ERROR_NETNAME_DELETED)
1156 ec = boost::asio::error::connection_reset;
1157 else if (ec.value() == ERROR_PORT_UNREACHABLE)
1158 ec = boost::asio::error::connection_refused;
1159 if (result != 0)
1160 return socket_error_retval;
1161 ec = boost::system::error_code();
1162 return bytes_transferred;
1163#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1164 msghdr msg = msghdr();
1165 msg.msg_iov = const_cast<buf*>(bufs);
1166 msg.msg_iovlen = static_cast<int>(count);
1167#if defined(__linux__)
1168 flags |= MSG_NOSIGNAL;
1169#endif // defined(__linux__)
1170 signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
1171 if (result >= 0)
1172 ec = boost::system::error_code();
1173 return result;
1174#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1175}
1176
1177size_t sync_send(socket_type s, state_type state, const buf* bufs,
1178 size_t count, int flags, bool all_empty, boost::system::error_code& ec)
1179{
1180 if (s == invalid_socket)
1181 {
1182 ec = boost::asio::error::bad_descriptor;
1183 return 0;
1184 }
1185
1186 // A request to write 0 bytes to a stream is a no-op.
1187 if (all_empty && (state & stream_oriented))
1188 {
1189 ec = boost::system::error_code();
1190 return 0;
1191 }
1192
1193 // Read some data.
1194 for (;;)
1195 {
1196 // Try to complete the operation without blocking.
1197 signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
1198
1199 // Check if operation succeeded.
1200 if (bytes >= 0)
1201 return bytes;
1202
1203 // Operation failed.
1204 if ((state & user_set_non_blocking)
1205 || (ec != boost::asio::error::would_block
1206 && ec != boost::asio::error::try_again))
1207 return 0;
1208
1209 // Wait for socket to become ready.
1210 if (socket_ops::poll_write(s, 0, ec) < 0)
1211 return 0;
1212 }
1213}
1214
1215#if defined(BOOST_ASIO_HAS_IOCP)
1216
1217void complete_iocp_send(
1218 const weak_cancel_token_type& cancel_token,
1219 boost::system::error_code& ec)
1220{
1221 // Map non-portable errors to their portable counterparts.
1222 if (ec.value() == ERROR_NETNAME_DELETED)
1223 {
1224 if (cancel_token.expired())
1225 ec = boost::asio::error::operation_aborted;
1226 else
1227 ec = boost::asio::error::connection_reset;
1228 }
1229 else if (ec.value() == ERROR_PORT_UNREACHABLE)
1230 {
1231 ec = boost::asio::error::connection_refused;
1232 }
1233}
1234
1235#else // defined(BOOST_ASIO_HAS_IOCP)
1236
1237bool non_blocking_send(socket_type s,
1238 const buf* bufs, size_t count, int flags,
1239 boost::system::error_code& ec, size_t& bytes_transferred)
1240{
1241 for (;;)
1242 {
1243 // Write some data.
1244 signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
1245
1246 // Retry operation if interrupted by signal.
1247 if (ec == boost::asio::error::interrupted)
1248 continue;
1249
1250 // Check if we need to run the operation again.
1251 if (ec == boost::asio::error::would_block
1252 || ec == boost::asio::error::try_again)
1253 return false;
1254
1255 // Operation is complete.
1256 if (bytes >= 0)
1257 {
1258 ec = boost::system::error_code();
1259 bytes_transferred = bytes;
1260 }
1261 else
1262 bytes_transferred = 0;
1263
1264 return true;
1265 }
1266}
1267
1268#endif // defined(BOOST_ASIO_HAS_IOCP)
1269
1270signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
1271 int flags, const socket_addr_type* addr, std::size_t addrlen,
1272 boost::system::error_code& ec)
1273{
1274 clear_last_error();
1275#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1276 // Send the data.
1277 DWORD send_buf_count = static_cast<DWORD>(count);
1278 DWORD bytes_transferred = 0;
1279 int result = error_wrapper(::WSASendTo(s, const_cast<buf*>(bufs),
1280 send_buf_count, &bytes_transferred, flags, addr,
1281 static_cast<int>(addrlen), 0, 0), ec);
1282 if (ec.value() == ERROR_NETNAME_DELETED)
1283 ec = boost::asio::error::connection_reset;
1284 else if (ec.value() == ERROR_PORT_UNREACHABLE)
1285 ec = boost::asio::error::connection_refused;
1286 if (result != 0)
1287 return socket_error_retval;
1288 ec = boost::system::error_code();
1289 return bytes_transferred;
1290#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1291 msghdr msg = msghdr();
1292 init_msghdr_msg_name(msg.msg_name, addr);
1293 msg.msg_namelen = static_cast<int>(addrlen);
1294 msg.msg_iov = const_cast<buf*>(bufs);
1295 msg.msg_iovlen = static_cast<int>(count);
1296#if defined(__linux__)
1297 flags |= MSG_NOSIGNAL;
1298#endif // defined(__linux__)
1299 signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
1300 if (result >= 0)
1301 ec = boost::system::error_code();
1302 return result;
1303#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1304}
1305
1306size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
1307 size_t count, int flags, const socket_addr_type* addr,
1308 std::size_t addrlen, boost::system::error_code& ec)
1309{
1310 if (s == invalid_socket)
1311 {
1312 ec = boost::asio::error::bad_descriptor;
1313 return 0;
1314 }
1315
1316 // Write some data.
1317 for (;;)
1318 {
1319 // Try to complete the operation without blocking.
1320 signed_size_type bytes = socket_ops::sendto(
1321 s, bufs, count, flags, addr, addrlen, ec);
1322
1323 // Check if operation succeeded.
1324 if (bytes >= 0)
1325 return bytes;
1326
1327 // Operation failed.
1328 if ((state & user_set_non_blocking)
1329 || (ec != boost::asio::error::would_block
1330 && ec != boost::asio::error::try_again))
1331 return 0;
1332
1333 // Wait for socket to become ready.
1334 if (socket_ops::poll_write(s, 0, ec) < 0)
1335 return 0;
1336 }
1337}
1338
1339#if !defined(BOOST_ASIO_HAS_IOCP)
1340
1341bool non_blocking_sendto(socket_type s,
1342 const buf* bufs, size_t count, int flags,
1343 const socket_addr_type* addr, std::size_t addrlen,
1344 boost::system::error_code& ec, size_t& bytes_transferred)
1345{
1346 for (;;)
1347 {
1348 // Write some data.
1349 signed_size_type bytes = socket_ops::sendto(
1350 s, bufs, count, flags, addr, addrlen, ec);
1351
1352 // Retry operation if interrupted by signal.
1353 if (ec == boost::asio::error::interrupted)
1354 continue;
1355
1356 // Check if we need to run the operation again.
1357 if (ec == boost::asio::error::would_block
1358 || ec == boost::asio::error::try_again)
1359 return false;
1360
1361 // Operation is complete.
1362 if (bytes >= 0)
1363 {
1364 ec = boost::system::error_code();
1365 bytes_transferred = bytes;
1366 }
1367 else
1368 bytes_transferred = 0;
1369
1370 return true;
1371 }
1372}
1373
1374#endif // !defined(BOOST_ASIO_HAS_IOCP)
1375
1376socket_type socket(int af, int type, int protocol,
1377 boost::system::error_code& ec)
1378{
1379 clear_last_error();
1380#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1381 socket_type s = error_wrapper(::WSASocketW(af, type, protocol, 0, 0,
1382 WSA_FLAG_OVERLAPPED), ec);
1383 if (s == invalid_socket)
1384 return s;
1385
1386 if (af == BOOST_ASIO_OS_DEF(AF_INET6))
1387 {
1388 // Try to enable the POSIX default behaviour of having IPV6_V6ONLY set to
1389 // false. This will only succeed on Windows Vista and later versions of
1390 // Windows, where a dual-stack IPv4/v6 implementation is available.
1391 DWORD optval = 0;
1392 ::setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
1393 reinterpret_cast<const char*>(&optval), sizeof(optval));
1394 }
1395
1396 ec = boost::system::error_code();
1397
1398 return s;
1399#elif defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
1400 socket_type s = error_wrapper(::socket(af, type, protocol), ec);
1401 if (s == invalid_socket)
1402 return s;
1403
1404 int optval = 1;
1405 int result = error_wrapper(::setsockopt(s,
1406 SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)), ec);
1407 if (result != 0)
1408 {
1409 ::close(s);
1410 return invalid_socket;
1411 }
1412
1413 return s;
1414#else
1415 int s = error_wrapper(::socket(af, type, protocol), ec);
1416 if (s >= 0)
1417 ec = boost::system::error_code();
1418 return s;
1419#endif
1420}
1421
1422template <typename SockLenType>
1423inline int call_setsockopt(SockLenType msghdr::*,
1424 socket_type s, int level, int optname,
1425 const void* optval, std::size_t optlen)
1426{
1427 return ::setsockopt(s, level, optname,
1428 (const char*)optval, (SockLenType)optlen);
1429}
1430
1431int setsockopt(socket_type s, state_type& state, int level, int optname,
1432 const void* optval, std::size_t optlen, boost::system::error_code& ec)
1433{
1434 if (s == invalid_socket)
1435 {
1436 ec = boost::asio::error::bad_descriptor;
1437 return socket_error_retval;
1438 }
1439
1440 if (level == custom_socket_option_level && optname == always_fail_option)
1441 {
1442 ec = boost::asio::error::invalid_argument;
1443 return socket_error_retval;
1444 }
1445
1446 if (level == custom_socket_option_level
1447 && optname == enable_connection_aborted_option)
1448 {
1449 if (optlen != sizeof(int))
1450 {
1451 ec = boost::asio::error::invalid_argument;
1452 return socket_error_retval;
1453 }
1454
1455 if (*static_cast<const int*>(optval))
1456 state |= enable_connection_aborted;
1457 else
1458 state &= ~enable_connection_aborted;
1459 ec = boost::system::error_code();
1460 return 0;
1461 }
1462
1463 if (level == SOL_SOCKET && optname == SO_LINGER)
1464 state |= user_set_linger;
1465
1466#if defined(__BORLANDC__)
1467 // Mysteriously, using the getsockopt and setsockopt functions directly with
1468 // Borland C++ results in incorrect values being set and read. The bug can be
1469 // worked around by using function addresses resolved with GetProcAddress.
1470 if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
1471 {
1472 typedef int (WSAAPI *sso_t)(SOCKET, int, int, const char*, int);
1473 if (sso_t sso = (sso_t)::GetProcAddress(winsock_module, "setsockopt"))
1474 {
1475 clear_last_error();
1476 return error_wrapper(sso(s, level, optname,
1477 reinterpret_cast<const char*>(optval),
1478 static_cast<int>(optlen)), ec);
1479 }
1480 }
1481 ec = boost::asio::error::fault;
1482 return socket_error_retval;
1483#else // defined(__BORLANDC__)
1484 clear_last_error();
1485 int result = error_wrapper(call_setsockopt(&msghdr::msg_namelen,
1486 s, level, optname, optval, optlen), ec);
1487 if (result == 0)
1488 {
1489 ec = boost::system::error_code();
1490
1491#if defined(__MACH__) && defined(__APPLE__) \
1492 || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
1493 // To implement portable behaviour for SO_REUSEADDR with UDP sockets we
1494 // need to also set SO_REUSEPORT on BSD-based platforms.
1495 if ((state & datagram_oriented)
1496 && level == SOL_SOCKET && optname == SO_REUSEADDR)
1497 {
1498 call_setsockopt(&msghdr::msg_namelen, s,
1499 SOL_SOCKET, SO_REUSEPORT, optval, optlen);
1500 }
1501#endif
1502 }
1503
1504 return result;
1505#endif // defined(__BORLANDC__)
1506}
1507
1508template <typename SockLenType>
1509inline int call_getsockopt(SockLenType msghdr::*,
1510 socket_type s, int level, int optname,
1511 void* optval, std::size_t* optlen)
1512{
1513 SockLenType tmp_optlen = (SockLenType)*optlen;
1514 int result = ::getsockopt(s, level, optname, (char*)optval, &tmp_optlen);
1515 *optlen = (std::size_t)tmp_optlen;
1516 return result;
1517}
1518
1519int getsockopt(socket_type s, state_type state, int level, int optname,
1520 void* optval, size_t* optlen, boost::system::error_code& ec)
1521{
1522 if (s == invalid_socket)
1523 {
1524 ec = boost::asio::error::bad_descriptor;
1525 return socket_error_retval;
1526 }
1527
1528 if (level == custom_socket_option_level && optname == always_fail_option)
1529 {
1530 ec = boost::asio::error::invalid_argument;
1531 return socket_error_retval;
1532 }
1533
1534 if (level == custom_socket_option_level
1535 && optname == enable_connection_aborted_option)
1536 {
1537 if (*optlen != sizeof(int))
1538 {
1539 ec = boost::asio::error::invalid_argument;
1540 return socket_error_retval;
1541 }
1542
1543 *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
1544 ec = boost::system::error_code();
1545 return 0;
1546 }
1547
1548#if defined(__BORLANDC__)
1549 // Mysteriously, using the getsockopt and setsockopt functions directly with
1550 // Borland C++ results in incorrect values being set and read. The bug can be
1551 // worked around by using function addresses resolved with GetProcAddress.
1552 if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
1553 {
1554 typedef int (WSAAPI *gso_t)(SOCKET, int, int, char*, int*);
1555 if (gso_t gso = (gso_t)::GetProcAddress(winsock_module, "getsockopt"))
1556 {
1557 clear_last_error();
1558 int tmp_optlen = static_cast<int>(*optlen);
1559 int result = error_wrapper(gso(s, level, optname,
1560 reinterpret_cast<char*>(optval), &tmp_optlen), ec);
1561 *optlen = static_cast<size_t>(tmp_optlen);
1562 if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
1563 && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
1564 {
1565 // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are
1566 // only supported on Windows Vista and later. To simplify program logic
1567 // we will fake success of getting this option and specify that the
1568 // value is non-zero (i.e. true). This corresponds to the behavior of
1569 // IPv6 sockets on Windows platforms pre-Vista.
1570 *static_cast<DWORD*>(optval) = 1;
1571 ec = boost::system::error_code();
1572 }
1573 return result;
1574 }
1575 }
1576 ec = boost::asio::error::fault;
1577 return socket_error_retval;
1578#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1579 clear_last_error();
1580 int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
1581 s, level, optname, optval, optlen), ec);
1582 if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
1583 && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
1584 {
1585 // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are only
1586 // supported on Windows Vista and later. To simplify program logic we will
1587 // fake success of getting this option and specify that the value is
1588 // non-zero (i.e. true). This corresponds to the behavior of IPv6 sockets
1589 // on Windows platforms pre-Vista.
1590 *static_cast<DWORD*>(optval) = 1;
1591 ec = boost::system::error_code();
1592 }
1593 if (result == 0)
1594 ec = boost::system::error_code();
1595 return result;
1596#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1597 clear_last_error();
1598 int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
1599 s, level, optname, optval, optlen), ec);
1600#if defined(__linux__)
1601 if (result == 0 && level == SOL_SOCKET && *optlen == sizeof(int)
1602 && (optname == SO_SNDBUF || optname == SO_RCVBUF))
1603 {
1604 // On Linux, setting SO_SNDBUF or SO_RCVBUF to N actually causes the kernel
1605 // to set the buffer size to N*2. Linux puts additional stuff into the
1606 // buffers so that only about half is actually available to the application.
1607 // The retrieved value is divided by 2 here to make it appear as though the
1608 // correct value has been set.
1609 *static_cast<int*>(optval) /= 2;
1610 }
1611#endif // defined(__linux__)
1612 if (result == 0)
1613 ec = boost::system::error_code();
1614 return result;
1615#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1616}
1617
1618template <typename SockLenType>
1619inline int call_getpeername(SockLenType msghdr::*,
1620 socket_type s, socket_addr_type* addr, std::size_t* addrlen)
1621{
1622 SockLenType tmp_addrlen = (SockLenType)*addrlen;
1623 int result = ::getpeername(s, addr, &tmp_addrlen);
1624 *addrlen = (std::size_t)tmp_addrlen;
1625 return result;
1626}
1627
1628int getpeername(socket_type s, socket_addr_type* addr,
1629 std::size_t* addrlen, bool cached, boost::system::error_code& ec)
1630{
1631 if (s == invalid_socket)
1632 {
1633 ec = boost::asio::error::bad_descriptor;
1634 return socket_error_retval;
1635 }
1636
1637#if defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP) \
1638 || defined(__CYGWIN__)
1639 if (cached)
1640 {
1641 // Check if socket is still connected.
1642 DWORD connect_time = 0;
1643 size_t connect_time_len = sizeof(connect_time);
1644 if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_CONNECT_TIME,
1645 &connect_time, &connect_time_len, ec) == socket_error_retval)
1646 {
1647 return socket_error_retval;
1648 }
1649 if (connect_time == 0xFFFFFFFF)
1650 {
1651 ec = boost::asio::error::not_connected;
1652 return socket_error_retval;
1653 }
1654
1655 // The cached value is still valid.
1656 ec = boost::system::error_code();
1657 return 0;
1658 }
1659#else // defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP)
1660 // || defined(__CYGWIN__)
1661 (void)cached;
1662#endif // defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP)
1663 // || defined(__CYGWIN__)
1664
1665 clear_last_error();
1666 int result = error_wrapper(call_getpeername(
1667 &msghdr::msg_namelen, s, addr, addrlen), ec);
1668 if (result == 0)
1669 ec = boost::system::error_code();
1670 return result;
1671}
1672
1673template <typename SockLenType>
1674inline int call_getsockname(SockLenType msghdr::*,
1675 socket_type s, socket_addr_type* addr, std::size_t* addrlen)
1676{
1677 SockLenType tmp_addrlen = (SockLenType)*addrlen;
1678 int result = ::getsockname(s, addr, &tmp_addrlen);
1679 *addrlen = (std::size_t)tmp_addrlen;
1680 return result;
1681}
1682
1683int getsockname(socket_type s, socket_addr_type* addr,
1684 std::size_t* addrlen, boost::system::error_code& ec)
1685{
1686 if (s == invalid_socket)
1687 {
1688 ec = boost::asio::error::bad_descriptor;
1689 return socket_error_retval;
1690 }
1691
1692 clear_last_error();
1693 int result = error_wrapper(call_getsockname(
1694 &msghdr::msg_namelen, s, addr, addrlen), ec);
1695 if (result == 0)
1696 ec = boost::system::error_code();
1697 return result;
1698}
1699
1700int ioctl(socket_type s, state_type& state, int cmd,
1701 ioctl_arg_type* arg, boost::system::error_code& ec)
1702{
1703 if (s == invalid_socket)
1704 {
1705 ec = boost::asio::error::bad_descriptor;
1706 return socket_error_retval;
1707 }
1708
1709 clear_last_error();
1710#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1711 int result = error_wrapper(::ioctlsocket(s, cmd, arg), ec);
1712#elif defined(__MACH__) && defined(__APPLE__) \
1713 || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
1714 int result = error_wrapper(::ioctl(s,
1715 static_cast<unsigned int>(cmd), arg), ec);
1716#else
1717 int result = error_wrapper(::ioctl(s, cmd, arg), ec);
1718#endif
1719 if (result >= 0)
1720 {
1721 ec = boost::system::error_code();
1722
1723 // When updating the non-blocking mode we always perform the ioctl syscall,
1724 // even if the flags would otherwise indicate that the socket is already in
1725 // the correct state. This ensures that the underlying socket is put into
1726 // the state that has been requested by the user. If the ioctl syscall was
1727 // successful then we need to update the flags to match.
1728 if (cmd == static_cast<int>(FIONBIO))
1729 {
1730 if (*arg)
1731 {
1732 state |= user_set_non_blocking;
1733 }
1734 else
1735 {
1736 // Clearing the non-blocking mode always overrides any internally-set
1737 // non-blocking flag. Any subsequent asynchronous operations will need
1738 // to re-enable non-blocking I/O.
1739 state &= ~(user_set_non_blocking | internal_non_blocking);
1740 }
1741 }
1742 }
1743
1744 return result;
1745}
1746
1747int select(int nfds, fd_set* readfds, fd_set* writefds,
1748 fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
1749{
1750 clear_last_error();
1751#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1752 if (!readfds && !writefds && !exceptfds && timeout)
1753 {
1754 DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
1755 if (milliseconds == 0)
1756 milliseconds = 1; // Force context switch.
1757 ::Sleep(milliseconds);
1758 ec = boost::system::error_code();
1759 return 0;
1760 }
1761
1762 // The select() call allows timeout values measured in microseconds, but the
1763 // system clock (as wrapped by boost::posix_time::microsec_clock) typically
1764 // has a resolution of 10 milliseconds. This can lead to a spinning select
1765 // reactor, meaning increased CPU usage, when waiting for the earliest
1766 // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight
1767 // spin we'll use a minimum timeout of 1 millisecond.
1768 if (timeout && timeout->tv_sec == 0
1769 && timeout->tv_usec > 0 && timeout->tv_usec < 1000)
1770 timeout->tv_usec = 1000;
1771#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1772
1773#if defined(__hpux) && defined(__SELECT)
1774 timespec ts;
1775 ts.tv_sec = timeout ? timeout->tv_sec : 0;
1776 ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0;
1777 return error_wrapper(::pselect(nfds, readfds,
1778 writefds, exceptfds, timeout ? &ts : 0, 0), ec);
1779#else
1780 int result = error_wrapper(::select(nfds, readfds,
1781 writefds, exceptfds, timeout), ec);
1782 if (result >= 0)
1783 ec = boost::system::error_code();
1784 return result;
1785#endif
1786}
1787
1788int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
1789{
1790 if (s == invalid_socket)
1791 {
1792 ec = boost::asio::error::bad_descriptor;
1793 return socket_error_retval;
1794 }
1795
1796#if defined(BOOST_ASIO_WINDOWS) \
1797 || defined(__CYGWIN__) \
1798 || defined(__SYMBIAN32__)
1799 fd_set fds;
1800 FD_ZERO(&fds);
1801 FD_SET(s, &fds);
1802 timeval zero_timeout;
1803 zero_timeout.tv_sec = 0;
1804 zero_timeout.tv_usec = 0;
1805 timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
1806 clear_last_error();
1807 int result = error_wrapper(::select(s + 1, &fds, 0, 0, timeout), ec);
1808#else // defined(BOOST_ASIO_WINDOWS)
1809 // || defined(__CYGWIN__)
1810 // || defined(__SYMBIAN32__)
1811 pollfd fds;
1812 fds.fd = s;
1813 fds.events = POLLIN;
1814 fds.revents = 0;
1815 int timeout = (state & user_set_non_blocking) ? 0 : -1;
1816 clear_last_error();
1817 int result = error_wrapper(::poll(&fds, 1, timeout), ec);
1818#endif // defined(BOOST_ASIO_WINDOWS)
1819 // || defined(__CYGWIN__)
1820 // || defined(__SYMBIAN32__)
1821 if (result == 0)
1822 ec = (state & user_set_non_blocking)
1823 ? boost::asio::error::would_block : boost::system::error_code();
1824 else if (result > 0)
1825 ec = boost::system::error_code();
1826 return result;
1827}
1828
1829int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
1830{
1831 if (s == invalid_socket)
1832 {
1833 ec = boost::asio::error::bad_descriptor;
1834 return socket_error_retval;
1835 }
1836
1837#if defined(BOOST_ASIO_WINDOWS) \
1838 || defined(__CYGWIN__) \
1839 || defined(__SYMBIAN32__)
1840 fd_set fds;
1841 FD_ZERO(&fds);
1842 FD_SET(s, &fds);
1843 timeval zero_timeout;
1844 zero_timeout.tv_sec = 0;
1845 zero_timeout.tv_usec = 0;
1846 timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
1847 clear_last_error();
1848 int result = error_wrapper(::select(s + 1, 0, &fds, 0, timeout), ec);
1849#else // defined(BOOST_ASIO_WINDOWS)
1850 // || defined(__CYGWIN__)
1851 // || defined(__SYMBIAN32__)
1852 pollfd fds;
1853 fds.fd = s;
1854 fds.events = POLLOUT;
1855 fds.revents = 0;
1856 int timeout = (state & user_set_non_blocking) ? 0 : -1;
1857 clear_last_error();
1858 int result = error_wrapper(::poll(&fds, 1, timeout), ec);
1859#endif // defined(BOOST_ASIO_WINDOWS)
1860 // || defined(__CYGWIN__)
1861 // || defined(__SYMBIAN32__)
1862 if (result == 0)
1863 ec = (state & user_set_non_blocking)
1864 ? boost::asio::error::would_block : boost::system::error_code();
1865 else if (result > 0)
1866 ec = boost::system::error_code();
1867 return result;
1868}
1869
1870int poll_connect(socket_type s, boost::system::error_code& ec)
1871{
1872 if (s == invalid_socket)
1873 {
1874 ec = boost::asio::error::bad_descriptor;
1875 return socket_error_retval;
1876 }
1877
1878#if defined(BOOST_ASIO_WINDOWS) \
1879 || defined(__CYGWIN__) \
1880 || defined(__SYMBIAN32__)
1881 fd_set write_fds;
1882 FD_ZERO(&write_fds);
1883 FD_SET(s, &write_fds);
1884 fd_set except_fds;
1885 FD_ZERO(&except_fds);
1886 FD_SET(s, &except_fds);
1887 clear_last_error();
1888 int result = error_wrapper(::select(
1889 s + 1, 0, &write_fds, &except_fds, 0), ec);
1890 if (result >= 0)
1891 ec = boost::system::error_code();
1892 return result;
1893#else // defined(BOOST_ASIO_WINDOWS)
1894 // || defined(__CYGWIN__)
1895 // || defined(__SYMBIAN32__)
1896 pollfd fds;
1897 fds.fd = s;
1898 fds.events = POLLOUT;
1899 fds.revents = 0;
1900 clear_last_error();
1901 int result = error_wrapper(::poll(&fds, 1, -1), ec);
1902 if (result >= 0)
1903 ec = boost::system::error_code();
1904 return result;
1905#endif // defined(BOOST_ASIO_WINDOWS)
1906 // || defined(__CYGWIN__)
1907 // || defined(__SYMBIAN32__)
1908}
1909
1910#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
1911
1912const char* inet_ntop(int af, const void* src, char* dest, size_t length,
1913 unsigned long scope_id, boost::system::error_code& ec)
1914{
1915 clear_last_error();
1916#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
1917 using namespace std; // For sprintf.
1918 const unsigned char* bytes = static_cast<const unsigned char*>(src);
1919 if (af == BOOST_ASIO_OS_DEF(AF_INET))
1920 {
1921 sprintf_s(dest, length, "%u.%u.%u.%u",
1922 bytes[0], bytes[1], bytes[2], bytes[3]);
1923 return dest;
1924 }
1925 else if (af == BOOST_ASIO_OS_DEF(AF_INET6))
1926 {
1927 size_t n = 0, b = 0, z = 0;
1928 while (n < length && b < 16)
1929 {
1930 if (bytes[b] == 0 && bytes[b + 1] == 0 && z == 0)
1931 {
1932 do b += 2; while (b < 16 && bytes[b] == 0 && bytes[b + 1] == 0);
1933 n += sprintf_s(dest + n, length - n, ":%s", b < 16 ? "" : ":"), ++z;
1934 }
1935 else
1936 {
1937 n += sprintf_s(dest + n, length - n, "%s%x", b ? ":" : "",
1938 (static_cast<u_long_type>(bytes[b]) << 8) | bytes[b + 1]);
1939 b += 2;
1940 }
1941 }
1942 if (scope_id)
1943 n += sprintf_s(dest + n, length - n, "%%%lu", scope_id);
1944 return dest;
1945 }
1946 else
1947 {
1948 ec = boost::asio::error::address_family_not_supported;
1949 return 0;
1950 }
1951#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
1952 using namespace std; // For memcpy.
1953
1954 if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6))
1955 {
1956 ec = boost::asio::error::address_family_not_supported;
1957 return 0;
1958 }
1959
1960 union
1961 {
1962 socket_addr_type base;
1963 sockaddr_storage_type storage;
1964 sockaddr_in4_type v4;
1965 sockaddr_in6_type v6;
1966 } address;
1967 DWORD address_length;
1968 if (af == BOOST_ASIO_OS_DEF(AF_INET))
1969 {
1970 address_length = sizeof(sockaddr_in4_type);
1971 address.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET);
1972 address.v4.sin_port = 0;
1973 memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type));
1974 }
1975 else // AF_INET6
1976 {
1977 address_length = sizeof(sockaddr_in6_type);
1978 address.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
1979 address.v6.sin6_port = 0;
1980 address.v6.sin6_flowinfo = 0;
1981 address.v6.sin6_scope_id = scope_id;
1982 memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type));
1983 }
1984
1985 DWORD string_length = static_cast<DWORD>(length);
1986#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
1987 LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR));
1988 int result = error_wrapper(::WSAAddressToStringW(&address.base,
1989 address_length, 0, string_buffer, &string_length), ec);
1990 ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1,
1991 dest, static_cast<int>(length), 0, 0);
1992#else
1993 int result = error_wrapper(::WSAAddressToStringA(
1994 &address.base, address_length, 0, dest, &string_length), ec);
1995#endif
1996
1997 // Windows may set error code on success.
1998 if (result != socket_error_retval)
1999 ec = boost::system::error_code();
2000
2001 // Windows may not set an error code on failure.
2002 else if (result == socket_error_retval && !ec)
2003 ec = boost::asio::error::invalid_argument;
2004
2005 return result == socket_error_retval ? 0 : dest;
2006#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2007 const char* result = error_wrapper(::inet_ntop(
2008 af, src, dest, static_cast<int>(length)), ec);
2009 if (result == 0 && !ec)
2010 ec = boost::asio::error::invalid_argument;
2011 if (result != 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id != 0)
2012 {
2013 using namespace std; // For strcat and sprintf.
2014 char if_name[IF_NAMESIZE + 1] = "%";
2015 const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
2016 bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
2017 && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
2018 bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
2019 && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
2020 if ((!is_link_local && !is_multicast_link_local)
2021 || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
2022 sprintf(if_name + 1, "%lu", scope_id);
2023 strcat(dest, if_name);
2024 }
2025 return result;
2026#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2027}
2028
2029int inet_pton(int af, const char* src, void* dest,
2030 unsigned long* scope_id, boost::system::error_code& ec)
2031{
2032 clear_last_error();
2033#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
2034 using namespace std; // For sscanf.
2035 unsigned char* bytes = static_cast<unsigned char*>(dest);
2036 if (af == BOOST_ASIO_OS_DEF(AF_INET))
2037 {
2038 unsigned int b0, b1, b2, b3;
2039 if (sscanf_s(src, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) != 4)
2040 {
2041 ec = boost::asio::error::invalid_argument;
2042 return -1;
2043 }
2044 if (b0 > 255 || b1 > 255 || b2 > 255 || b3 > 255)
2045 {
2046 ec = boost::asio::error::invalid_argument;
2047 return -1;
2048 }
2049 bytes[0] = static_cast<unsigned char>(b0);
2050 bytes[1] = static_cast<unsigned char>(b1);
2051 bytes[2] = static_cast<unsigned char>(b2);
2052 bytes[3] = static_cast<unsigned char>(b3);
2053 ec = boost::system::error_code();
2054 return 1;
2055 }
2056 else if (af == BOOST_ASIO_OS_DEF(AF_INET6))
2057 {
2058 unsigned char* bytes = static_cast<unsigned char*>(dest);
2059 std::memset(bytes, 0, 16);
2060 unsigned char back_bytes[16] = { 0 };
2061 int num_front_bytes = 0, num_back_bytes = 0;
2062 const char* p = src;
2063
2064 enum { fword, fcolon, bword, scope, done } state = fword;
2065 unsigned long current_word = 0;
2066 while (state != done)
2067 {
2068 if (current_word > 0xFFFF)
2069 {
2070 ec = boost::asio::error::invalid_argument;
2071 return -1;
2072 }
2073
2074 switch (state)
2075 {
2076 case fword:
2077 if (*p >= '0' && *p <= '9')
2078 current_word = current_word * 16 + *p++ - '0';
2079 else if (*p >= 'a' && *p <= 'f')
2080 current_word = current_word * 16 + *p++ - 'a' + 10;
2081 else if (*p >= 'A' && *p <= 'F')
2082 current_word = current_word * 16 + *p++ - 'A' + 10;
2083 else
2084 {
2085 if (num_front_bytes == 16)
2086 {
2087 ec = boost::asio::error::invalid_argument;
2088 return -1;
2089 }
2090
2091 bytes[num_front_bytes++] = (current_word >> 8) & 0xFF;
2092 bytes[num_front_bytes++] = current_word & 0xFF;
2093 current_word = 0;
2094
2095 if (*p == ':')
2096 state = fcolon, ++p;
2097 else if (*p == '%')
2098 state = scope, ++p;
2099 else if (*p == 0)
2100 state = done;
2101 else
2102 {
2103 ec = boost::asio::error::invalid_argument;
2104 return -1;
2105 }
2106 }
2107 break;
2108
2109 case fcolon:
2110 if (*p == ':')
2111 state = bword, ++p;
2112 else
2113 state = fword;
2114 break;
2115
2116 case bword:
2117 if (*p >= '0' && *p <= '9')
2118 current_word = current_word * 16 + *p++ - '0';
2119 else if (*p >= 'a' && *p <= 'f')
2120 current_word = current_word * 16 + *p++ - 'a' + 10;
2121 else if (*p >= 'A' && *p <= 'F')
2122 current_word = current_word * 16 + *p++ - 'A' + 10;
2123 else
2124 {
2125 if (num_front_bytes + num_back_bytes == 16)
2126 {
2127 ec = boost::asio::error::invalid_argument;
2128 return -1;
2129 }
2130
2131 back_bytes[num_back_bytes++] = (current_word >> 8) & 0xFF;
2132 back_bytes[num_back_bytes++] = current_word & 0xFF;
2133 current_word = 0;
2134
2135 if (*p == ':')
2136 state = bword, ++p;
2137 else if (*p == '%')
2138 state = scope, ++p;
2139 else if (*p == 0)
2140 state = done;
2141 else
2142 {
2143 ec = boost::asio::error::invalid_argument;
2144 return -1;
2145 }
2146 }
2147 break;
2148
2149 case scope:
2150 if (*p >= '0' && *p <= '9')
2151 current_word = current_word * 10 + *p++ - '0';
2152 else if (*p == 0)
2153 *scope_id = current_word, state = done;
2154 else
2155 {
2156 ec = boost::asio::error::invalid_argument;
2157 return -1;
2158 }
2159 break;
2160
2161 default:
2162 break;
2163 }
2164 }
2165
2166 for (int i = 0; i < num_back_bytes; ++i)
2167 bytes[16 - num_back_bytes + i] = back_bytes[i];
2168
2169 ec = boost::system::error_code();
2170 return 1;
2171 }
2172 else
2173 {
2174 ec = boost::asio::error::address_family_not_supported;
2175 return -1;
2176 }
2177#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2178 using namespace std; // For memcpy and strcmp.
2179
2180 if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6))
2181 {
2182 ec = boost::asio::error::address_family_not_supported;
2183 return -1;
2184 }
2185
2186 union
2187 {
2188 socket_addr_type base;
2189 sockaddr_storage_type storage;
2190 sockaddr_in4_type v4;
2191 sockaddr_in6_type v6;
2192 } address;
2193 int address_length = sizeof(sockaddr_storage_type);
2194#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
2195 int num_wide_chars = static_cast<int>(strlen(src)) + 1;
2196 LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR));
2197 ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars);
2198 int result = error_wrapper(::WSAStringToAddressW(
2199 wide_buffer, af, 0, &address.base, &address_length), ec);
2200#else
2201 int result = error_wrapper(::WSAStringToAddressA(
2202 const_cast<char*>(src), af, 0, &address.base, &address_length), ec);
2203#endif
2204
2205 if (af == BOOST_ASIO_OS_DEF(AF_INET))
2206 {
2207 if (result != socket_error_retval)
2208 {
2209 memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
2210 ec = boost::system::error_code();
2211 }
2212 else if (strcmp(src, "255.255.255.255") == 0)
2213 {
2214 static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
2215 ec = boost::system::error_code();
2216 }
2217 }
2218 else // AF_INET6
2219 {
2220 if (result != socket_error_retval)
2221 {
2222 memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
2223 if (scope_id)
2224 *scope_id = address.v6.sin6_scope_id;
2225 ec = boost::system::error_code();
2226 }
2227 }
2228
2229 // Windows may not set an error code on failure.
2230 if (result == socket_error_retval && !ec)
2231 ec = boost::asio::error::invalid_argument;
2232
2233 if (result != socket_error_retval)
2234 ec = boost::system::error_code();
2235
2236 return result == socket_error_retval ? -1 : 1;
2237#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2238 using namespace std; // For strchr, memcpy and atoi.
2239
2240 // On some platforms, inet_pton fails if an address string contains a scope
2241 // id. Detect and remove the scope id before passing the string to inet_pton.
2242 const bool is_v6 = (af == BOOST_ASIO_OS_DEF(AF_INET6));
2243 const char* if_name = is_v6 ? strchr(src, '%') : 0;
2244 char src_buf[max_addr_v6_str_len + 1];
2245 const char* src_ptr = src;
2246 if (if_name != 0)
2247 {
2248 if (if_name - src > max_addr_v6_str_len)
2249 {
2250 ec = boost::asio::error::invalid_argument;
2251 return 0;
2252 }
2253 memcpy(src_buf, src, if_name - src);
2254 src_buf[if_name - src] = 0;
2255 src_ptr = src_buf;
2256 }
2257
2258 int result = error_wrapper(::inet_pton(af, src_ptr, dest), ec);
2259 if (result <= 0 && !ec)
2260 ec = boost::asio::error::invalid_argument;
2261 if (result > 0 && is_v6 && scope_id)
2262 {
2263 using namespace std; // For strchr and atoi.
2264 *scope_id = 0;
2265 if (if_name != 0)
2266 {
2267 in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
2268 bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
2269 && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
2270 bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
2271 && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
2272 if (is_link_local || is_multicast_link_local)
2273 *scope_id = if_nametoindex(if_name + 1);
2274 if (*scope_id == 0)
2275 *scope_id = atoi(if_name + 1);
2276 }
2277 }
2278 return result;
2279#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2280}
2281
2282int gethostname(char* name, int namelen, boost::system::error_code& ec)
2283{
2284 clear_last_error();
2285#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
2286 try
2287 {
2288 using namespace Windows::Foundation::Collections;
2289 using namespace Windows::Networking;
2290 using namespace Windows::Networking::Connectivity;
2291 IVectorView<HostName^>^ hostnames = NetworkInformation::GetHostNames();
2292 for (unsigned i = 0; i < hostnames->Size; ++i)
2293 {
2294 HostName^ hostname = hostnames->GetAt(i);
2295 if (hostname->Type == HostNameType::DomainName)
2296 {
2297 std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
2298 std::string raw_name = converter.to_bytes(hostname->RawName->Data());
2299 if (namelen > 0 && raw_name.size() < static_cast<std::size_t>(namelen))
2300 {
2301 strcpy_s(name, namelen, raw_name.c_str());
2302 return 0;
2303 }
2304 }
2305 }
2306 return -1;
2307 }
2308 catch (Platform::Exception^ e)
2309 {
2310 ec = boost::system::error_code(e->HResult,
2311 boost::system::system_category());
2312 return -1;
2313 }
2314#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
2315 int result = error_wrapper(::gethostname(name, namelen), ec);
2316# if defined(BOOST_ASIO_WINDOWS)
2317 if (result == 0)
2318 ec = boost::system::error_code();
2319# endif // defined(BOOST_ASIO_WINDOWS)
2320 return result;
2321#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
2322}
2323
2324#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
2325
2326#if !defined(BOOST_ASIO_HAS_GETADDRINFO)
2327
2328// The following functions are only needed for emulation of getaddrinfo and
2329// getnameinfo.
2330
2331inline boost::system::error_code translate_netdb_error(int error)
2332{
2333 switch (error)
2334 {
2335 case 0:
2336 return boost::system::error_code();
2337 case HOST_NOT_FOUND:
2338 return boost::asio::error::host_not_found;
2339 case TRY_AGAIN:
2340 return boost::asio::error::host_not_found_try_again;
2341 case NO_RECOVERY:
2342 return boost::asio::error::no_recovery;
2343 case NO_DATA:
2344 return boost::asio::error::no_data;
2345 default:
2346 BOOST_ASIO_ASSERT(false);
2347 return boost::asio::error::invalid_argument;
2348 }
2349}
2350
2351inline hostent* gethostbyaddr(const char* addr, int length, int af,
2352 hostent* result, char* buffer, int buflength, boost::system::error_code& ec)
2353{
2354 clear_last_error();
2355#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2356 (void)(buffer);
2357 (void)(buflength);
2358 hostent* retval = error_wrapper(::gethostbyaddr(addr, length, af), ec);
2359 if (!retval)
2360 return 0;
2361 ec = boost::system::error_code();
2362 *result = *retval;
2363 return retval;
2364#elif defined(__sun) || defined(__QNX__)
2365 int error = 0;
2366 hostent* retval = error_wrapper(::gethostbyaddr_r(addr, length, af, result,
2367 buffer, buflength, &error), ec);
2368 if (error)
2369 ec = translate_netdb_error(error);
2370 return retval;
2371#elif defined(__MACH__) && defined(__APPLE__)
2372 (void)(buffer);
2373 (void)(buflength);
2374 int error = 0;
2375 hostent* retval = error_wrapper(::getipnodebyaddr(
2376 addr, length, af, &error), ec);
2377 if (error)
2378 ec = translate_netdb_error(error);
2379 if (!retval)
2380 return 0;
2381 *result = *retval;
2382 return retval;
2383#else
2384 hostent* retval = 0;
2385 int error = 0;
2386 error_wrapper(::gethostbyaddr_r(addr, length, af, result, buffer,
2387 buflength, &retval, &error), ec);
2388 if (error)
2389 ec = translate_netdb_error(error);
2390 return retval;
2391#endif
2392}
2393
2394inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
2395 char* buffer, int buflength, int ai_flags, boost::system::error_code& ec)
2396{
2397 clear_last_error();
2398#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
2399 (void)(buffer);
2400 (void)(buflength);
2401 (void)(ai_flags);
2402 if (af != BOOST_ASIO_OS_DEF(AF_INET))
2403 {
2404 ec = boost::asio::error::address_family_not_supported;
2405 return 0;
2406 }
2407 hostent* retval = error_wrapper(::gethostbyname(name), ec);
2408 if (!retval)
2409 return 0;
2410 ec = boost::system::error_code();
2411 *result = *retval;
2412 return result;
2413#elif defined(__sun) || defined(__QNX__)
2414 (void)(ai_flags);
2415 if (af != BOOST_ASIO_OS_DEF(AF_INET))
2416 {
2417 ec = boost::asio::error::address_family_not_supported;
2418 return 0;
2419 }
2420 int error = 0;
2421 hostent* retval = error_wrapper(::gethostbyname_r(name, result, buffer,
2422 buflength, &error), ec);
2423 if (error)
2424 ec = translate_netdb_error(error);
2425 return retval;
2426#elif defined(__MACH__) && defined(__APPLE__)
2427 (void)(buffer);
2428 (void)(buflength);
2429 int error = 0;
2430 hostent* retval = error_wrapper(::getipnodebyname(
2431 name, af, ai_flags, &error), ec);
2432 if (error)
2433 ec = translate_netdb_error(error);
2434 if (!retval)
2435 return 0;
2436 *result = *retval;
2437 return retval;
2438#else
2439 (void)(ai_flags);
2440 if (af != BOOST_ASIO_OS_DEF(AF_INET))
2441 {
2442 ec = boost::asio::error::address_family_not_supported;
2443 return 0;
2444 }
2445 hostent* retval = 0;
2446 int error = 0;
2447 error_wrapper(::gethostbyname_r(name, result,
2448 buffer, buflength, &retval, &error), ec);
2449 if (error)
2450 ec = translate_netdb_error(error);
2451 return retval;
2452#endif
2453}
2454
2455inline void freehostent(hostent* h)
2456{
2457#if defined(__MACH__) && defined(__APPLE__)
2458 if (h)
2459 ::freehostent(h);
2460#else
2461 (void)(h);
2462#endif
2463}
2464
2465// Emulation of getaddrinfo based on implementation in:
2466// Stevens, W. R., UNIX Network Programming Vol. 1, 2nd Ed., Prentice-Hall 1998.
2467
2468struct gai_search
2469{
2470 const char* host;
2471 int family;
2472};
2473
2474inline int gai_nsearch(const char* host,
2475 const addrinfo_type* hints, gai_search (&search)[2])
2476{
2477 int search_count = 0;
2478 if (host == 0 || host[0] == '\0')
2479 {
2480 if (hints->ai_flags & AI_PASSIVE)
2481 {
2482 // No host and AI_PASSIVE implies wildcard bind.
2483 switch (hints->ai_family)
2484 {
2485 case BOOST_ASIO_OS_DEF(AF_INET):
2486 search[search_count].host = "0.0.0.0";
2487 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
2488 ++search_count;
2489 break;
2490 case BOOST_ASIO_OS_DEF(AF_INET6):
2491 search[search_count].host = "0::0";
2492 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
2493 ++search_count;
2494 break;
2495 case BOOST_ASIO_OS_DEF(AF_UNSPEC):
2496 search[search_count].host = "0::0";
2497 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
2498 ++search_count;
2499 search[search_count].host = "0.0.0.0";
2500 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
2501 ++search_count;
2502 break;
2503 default:
2504 break;
2505 }
2506 }
2507 else
2508 {
2509 // No host and not AI_PASSIVE means connect to local host.
2510 switch (hints->ai_family)
2511 {
2512 case BOOST_ASIO_OS_DEF(AF_INET):
2513 search[search_count].host = "localhost";
2514 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
2515 ++search_count;
2516 break;
2517 case BOOST_ASIO_OS_DEF(AF_INET6):
2518 search[search_count].host = "localhost";
2519 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
2520 ++search_count;
2521 break;
2522 case BOOST_ASIO_OS_DEF(AF_UNSPEC):
2523 search[search_count].host = "localhost";
2524 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
2525 ++search_count;
2526 search[search_count].host = "localhost";
2527 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
2528 ++search_count;
2529 break;
2530 default:
2531 break;
2532 }
2533 }
2534 }
2535 else
2536 {
2537 // Host is specified.
2538 switch (hints->ai_family)
2539 {
2540 case BOOST_ASIO_OS_DEF(AF_INET):
2541 search[search_count].host = host;
2542 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
2543 ++search_count;
2544 break;
2545 case BOOST_ASIO_OS_DEF(AF_INET6):
2546 search[search_count].host = host;
2547 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
2548 ++search_count;
2549 break;
2550 case BOOST_ASIO_OS_DEF(AF_UNSPEC):
2551 search[search_count].host = host;
2552 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
2553 ++search_count;
2554 search[search_count].host = host;
2555 search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
2556 ++search_count;
2557 break;
2558 default:
2559 break;
2560 }
2561 }
2562 return search_count;
2563}
2564
2565template <typename T>
2566inline T* gai_alloc(std::size_t size = sizeof(T))
2567{
2568 using namespace std;
2569 T* p = static_cast<T*>(::operator new(size, std::nothrow));
2570 if (p)
2571 memset(p, 0, size);
2572 return p;
2573}
2574
2575inline void gai_free(void* p)
2576{
2577 ::operator delete(p);
2578}
2579
2580inline void gai_strcpy(char* target, const char* source, std::size_t max_size)
2581{
2582 using namespace std;
2583#if defined(BOOST_ASIO_HAS_SECURE_RTL)
2584 strcpy_s(target, max_size, source);
2585#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
2586 *target = 0;
2587 if (max_size > 0)
2588 strncat(target, source, max_size - 1);
2589#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
2590}
2591
2592enum { gai_clone_flag = 1 << 30 };
2593
2594inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints,
2595 const void* addr, int family)
2596{
2597 using namespace std;
2598
2599 addrinfo_type* ai = gai_alloc<addrinfo_type>();
2600 if (ai == 0)
2601 return EAI_MEMORY;
2602
2603 ai->ai_next = 0;
2604 **next = ai;
2605 *next = &ai->ai_next;
2606
2607 ai->ai_canonname = 0;
2608 ai->ai_socktype = hints->ai_socktype;
2609 if (ai->ai_socktype == 0)
2610 ai->ai_flags |= gai_clone_flag;
2611 ai->ai_protocol = hints->ai_protocol;
2612 ai->ai_family = family;
2613
2614 switch (ai->ai_family)
2615 {
2616 case BOOST_ASIO_OS_DEF(AF_INET):
2617 {
2618 sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>();
2619 if (sinptr == 0)
2620 return EAI_MEMORY;
2621 sinptr->sin_family = BOOST_ASIO_OS_DEF(AF_INET);
2622 memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type));
2623 ai->ai_addr = reinterpret_cast<sockaddr*>(sinptr);
2624 ai->ai_addrlen = sizeof(sockaddr_in4_type);
2625 break;
2626 }
2627 case BOOST_ASIO_OS_DEF(AF_INET6):
2628 {
2629 sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>();
2630 if (sin6ptr == 0)
2631 return EAI_MEMORY;
2632 sin6ptr->sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
2633 memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type));
2634 ai->ai_addr = reinterpret_cast<sockaddr*>(sin6ptr);
2635 ai->ai_addrlen = sizeof(sockaddr_in6_type);
2636 break;
2637 }
2638 default:
2639 break;
2640 }
2641
2642 return 0;
2643}
2644
2645inline addrinfo_type* gai_clone(addrinfo_type* ai)
2646{
2647 using namespace std;
2648
2649 addrinfo_type* new_ai = gai_alloc<addrinfo_type>();
2650 if (new_ai == 0)
2651 return new_ai;
2652
2653 new_ai->ai_next = ai->ai_next;
2654 ai->ai_next = new_ai;
2655
2656 new_ai->ai_flags = 0;
2657 new_ai->ai_family = ai->ai_family;
2658 new_ai->ai_socktype = ai->ai_socktype;
2659 new_ai->ai_protocol = ai->ai_protocol;
2660 new_ai->ai_canonname = 0;
2661 new_ai->ai_addrlen = ai->ai_addrlen;
2662 new_ai->ai_addr = gai_alloc<sockaddr>(ai->ai_addrlen);
2663 memcpy(new_ai->ai_addr, ai->ai_addr, ai->ai_addrlen);
2664
2665 return new_ai;
2666}
2667
2668inline int gai_port(addrinfo_type* aihead, int port, int socktype)
2669{
2670 int num_found = 0;
2671
2672 for (addrinfo_type* ai = aihead; ai; ai = ai->ai_next)
2673 {
2674 if (ai->ai_flags & gai_clone_flag)
2675 {
2676 if (ai->ai_socktype != 0)
2677 {
2678 ai = gai_clone(ai);
2679 if (ai == 0)
2680 return -1;
2681 // ai now points to newly cloned entry.
2682 }
2683 }
2684 else if (ai->ai_socktype != socktype)
2685 {
2686 // Ignore if mismatch on socket type.
2687 continue;
2688 }
2689
2690 ai->ai_socktype = socktype;
2691
2692 switch (ai->ai_family)
2693 {
2694 case BOOST_ASIO_OS_DEF(AF_INET):
2695 {
2696 sockaddr_in4_type* sinptr =
2697 reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
2698 sinptr->sin_port = port;
2699 ++num_found;
2700 break;
2701 }
2702 case BOOST_ASIO_OS_DEF(AF_INET6):
2703 {
2704 sockaddr_in6_type* sin6ptr =
2705 reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
2706 sin6ptr->sin6_port = port;
2707 ++num_found;
2708 break;
2709 }
2710 default:
2711 break;
2712 }
2713 }
2714
2715 return num_found;
2716}
2717
2718inline int gai_serv(addrinfo_type* aihead,
2719 const addrinfo_type* hints, const char* serv)
2720{
2721 using namespace std;
2722
2723 int num_found = 0;
2724
2725 if (
2726#if defined(AI_NUMERICSERV)
2727 (hints->ai_flags & AI_NUMERICSERV) ||
2728#endif
2729 isdigit(static_cast<unsigned char>(serv[0])))
2730 {
2731 int port = htons(atoi(serv));
2732 if (hints->ai_socktype)
2733 {
2734 // Caller specifies socket type.
2735 int rc = gai_port(aihead, port, hints->ai_socktype);
2736 if (rc < 0)
2737 return EAI_MEMORY;
2738 num_found += rc;
2739 }
2740 else
2741 {
2742 // Caller does not specify socket type.
2743 int rc = gai_port(aihead, port, SOCK_STREAM);
2744 if (rc < 0)
2745 return EAI_MEMORY;
2746 num_found += rc;
2747 rc = gai_port(aihead, port, SOCK_DGRAM);
2748 if (rc < 0)
2749 return EAI_MEMORY;
2750 num_found += rc;
2751 }
2752 }
2753 else
2754 {
2755 // Try service name with TCP first, then UDP.
2756 if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_STREAM)
2757 {
2758 servent* sptr = getservbyname(serv, "tcp");
2759 if (sptr != 0)
2760 {
2761 int rc = gai_port(aihead, sptr->s_port, SOCK_STREAM);
2762 if (rc < 0)
2763 return EAI_MEMORY;
2764 num_found += rc;
2765 }
2766 }
2767 if (hints->ai_socktype == 0 || hints->ai_socktype == SOCK_DGRAM)
2768 {
2769 servent* sptr = getservbyname(serv, "udp");
2770 if (sptr != 0)
2771 {
2772 int rc = gai_port(aihead, sptr->s_port, SOCK_DGRAM);
2773 if (rc < 0)
2774 return EAI_MEMORY;
2775 num_found += rc;
2776 }
2777 }
2778 }
2779
2780 if (num_found == 0)
2781 {
2782 if (hints->ai_socktype == 0)
2783 {
2784 // All calls to getservbyname() failed.
2785 return EAI_NONAME;
2786 }
2787 else
2788 {
2789 // Service not supported for socket type.
2790 return EAI_SERVICE;
2791 }
2792 }
2793
2794 return 0;
2795}
2796
2797inline int gai_echeck(const char* host, const char* service,
2798 int flags, int family, int socktype, int protocol)
2799{
2800 (void)(flags);
2801 (void)(protocol);
2802
2803 // Host or service must be specified.
2804 if (host == 0 || host[0] == '\0')
2805 if (service == 0 || service[0] == '\0')
2806 return EAI_NONAME;
2807
2808 // Check combination of family and socket type.
2809 switch (family)
2810 {
2811 case BOOST_ASIO_OS_DEF(AF_UNSPEC):
2812 break;
2813 case BOOST_ASIO_OS_DEF(AF_INET):
2814 case BOOST_ASIO_OS_DEF(AF_INET6):
2815 if (service != 0 && service[0] != '\0')
2816 if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM)
2817 return EAI_SOCKTYPE;
2818 break;
2819 default:
2820 return EAI_FAMILY;
2821 }
2822
2823 return 0;
2824}
2825
2826inline void freeaddrinfo_emulation(addrinfo_type* aihead)
2827{
2828 addrinfo_type* ai = aihead;
2829 while (ai)
2830 {
2831 gai_free(ai->ai_addr);
2832 gai_free(ai->ai_canonname);
2833 addrinfo_type* ainext = ai->ai_next;
2834 gai_free(ai);
2835 ai = ainext;
2836 }
2837}
2838
2839inline int getaddrinfo_emulation(const char* host, const char* service,
2840 const addrinfo_type* hintsp, addrinfo_type** result)
2841{
2842 // Set up linked list of addrinfo structures.
2843 addrinfo_type* aihead = 0;
2844 addrinfo_type** ainext = &aihead;
2845 char* canon = 0;
2846
2847 // Supply default hints if not specified by caller.
2848 addrinfo_type hints = addrinfo_type();
2849 hints.ai_family = BOOST_ASIO_OS_DEF(AF_UNSPEC);
2850 if (hintsp)
2851 hints = *hintsp;
2852
2853 // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED
2854 // and AI_ALL flags.
2855#if defined(AI_V4MAPPED)
2856 if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
2857 hints.ai_flags &= ~AI_V4MAPPED;
2858#endif
2859#if defined(AI_ALL)
2860 if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
2861 hints.ai_flags &= ~AI_ALL;
2862#endif
2863
2864 // Basic error checking.
2865 int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family,
2866 hints.ai_socktype, hints.ai_protocol);
2867 if (rc != 0)
2868 {
2869 freeaddrinfo_emulation(aihead);
2870 return rc;
2871 }
2872
2873 gai_search search[2];
2874 int search_count = gai_nsearch(host, &hints, search);
2875 for (gai_search* sptr = search; sptr < search + search_count; ++sptr)
2876 {
2877 // Check for IPv4 dotted decimal string.
2878 in4_addr_type inaddr;
2879 boost::system::error_code ec;
2880 if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET),
2881 sptr->host, &inaddr, 0, ec) == 1)
2882 {
2883 if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
2884 && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET))
2885 {
2886 freeaddrinfo_emulation(aihead);
2887 gai_free(canon);
2888 return EAI_FAMILY;
2889 }
2890 if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET))
2891 {
2892 rc = gai_aistruct(&ainext, &hints, &inaddr, BOOST_ASIO_OS_DEF(AF_INET));
2893 if (rc != 0)
2894 {
2895 freeaddrinfo_emulation(aihead);
2896 gai_free(canon);
2897 return rc;
2898 }
2899 }
2900 continue;
2901 }
2902
2903 // Check for IPv6 hex string.
2904 in6_addr_type in6addr;
2905 if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6),
2906 sptr->host, &in6addr, 0, ec) == 1)
2907 {
2908 if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
2909 && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
2910 {
2911 freeaddrinfo_emulation(aihead);
2912 gai_free(canon);
2913 return EAI_FAMILY;
2914 }
2915 if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET6))
2916 {
2917 rc = gai_aistruct(&ainext, &hints, &in6addr,
2918 BOOST_ASIO_OS_DEF(AF_INET6));
2919 if (rc != 0)
2920 {
2921 freeaddrinfo_emulation(aihead);
2922 gai_free(canon);
2923 return rc;
2924 }
2925 }
2926 continue;
2927 }
2928
2929 // Look up hostname.
2930 hostent hent;
2931 char hbuf[8192] = "";
2932 hostent* hptr = socket_ops::gethostbyname(sptr->host,
2933 sptr->family, &hent, hbuf, sizeof(hbuf), hints.ai_flags, ec);
2934 if (hptr == 0)
2935 {
2936 if (search_count == 2)
2937 {
2938 // Failure is OK if there are multiple searches.
2939 continue;
2940 }
2941 freeaddrinfo_emulation(aihead);
2942 gai_free(canon);
2943 if (ec == boost::asio::error::host_not_found)
2944 return EAI_NONAME;
2945 if (ec == boost::asio::error::host_not_found_try_again)
2946 return EAI_AGAIN;
2947 if (ec == boost::asio::error::no_recovery)
2948 return EAI_FAIL;
2949 if (ec == boost::asio::error::no_data)
2950 return EAI_NONAME;
2951 return EAI_NONAME;
2952 }
2953
2954 // Check for address family mismatch if one was specified.
2955 if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
2956 && hints.ai_family != hptr->h_addrtype)
2957 {
2958 freeaddrinfo_emulation(aihead);
2959 gai_free(canon);
2960 socket_ops::freehostent(hptr);
2961 return EAI_FAMILY;
2962 }
2963
2964 // Save canonical name first time.
2965 if (host != 0 && host[0] != '\0' && hptr->h_name && hptr->h_name[0]
2966 && (hints.ai_flags & AI_CANONNAME) && canon == 0)
2967 {
2968 std::size_t canon_len = strlen(hptr->h_name) + 1;
2969 canon = gai_alloc<char>(canon_len);
2970 if (canon == 0)
2971 {
2972 freeaddrinfo_emulation(aihead);
2973 socket_ops::freehostent(hptr);
2974 return EAI_MEMORY;
2975 }
2976 gai_strcpy(canon, hptr->h_name, canon_len);
2977 }
2978
2979 // Create an addrinfo structure for each returned address.
2980 for (char** ap = hptr->h_addr_list; *ap; ++ap)
2981 {
2982 rc = gai_aistruct(&ainext, &hints, *ap, hptr->h_addrtype);
2983 if (rc != 0)
2984 {
2985 freeaddrinfo_emulation(aihead);
2986 gai_free(canon);
2987 socket_ops::freehostent(hptr);
2988 return EAI_FAMILY;
2989 }
2990 }
2991
2992 socket_ops::freehostent(hptr);
2993 }
2994
2995 // Check if we found anything.
2996 if (aihead == 0)
2997 {
2998 gai_free(canon);
2999 return EAI_NONAME;
3000 }
3001
3002 // Return canonical name in first entry.
3003 if (host != 0 && host[0] != '\0' && (hints.ai_flags & AI_CANONNAME))
3004 {
3005 if (canon)
3006 {
3007 aihead->ai_canonname = canon;
3008 canon = 0;
3009 }
3010 else
3011 {
3012 std::size_t canonname_len = strlen(search[0].host) + 1;
3013 aihead->ai_canonname = gai_alloc<char>(canonname_len);
3014 if (aihead->ai_canonname == 0)
3015 {
3016 freeaddrinfo_emulation(aihead);
3017 return EAI_MEMORY;
3018 }
3019 gai_strcpy(aihead->ai_canonname, search[0].host, canonname_len);
3020 }
3021 }
3022 gai_free(canon);
3023
3024 // Process the service name.
3025 if (service != 0 && service[0] != '\0')
3026 {
3027 rc = gai_serv(aihead, &hints, service);
3028 if (rc != 0)
3029 {
3030 freeaddrinfo_emulation(aihead);
3031 return rc;
3032 }
3033 }
3034
3035 // Return result to caller.
3036 *result = aihead;
3037 return 0;
3038}
3039
3040inline boost::system::error_code getnameinfo_emulation(
3041 const socket_addr_type* sa, std::size_t salen, char* host,
3042 std::size_t hostlen, char* serv, std::size_t servlen, int flags,
3043 boost::system::error_code& ec)
3044{
3045 using namespace std;
3046
3047 const char* addr;
3048 size_t addr_len;
3049 unsigned short port;
3050 switch (sa->sa_family)
3051 {
3052 case BOOST_ASIO_OS_DEF(AF_INET):
3053 if (salen != sizeof(sockaddr_in4_type))
3054 {
3055 return ec = boost::asio::error::invalid_argument;
3056 }
3057 addr = reinterpret_cast<const char*>(
3058 &reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_addr);
3059 addr_len = sizeof(in4_addr_type);
3060 port = reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_port;
3061 break;
3062 case BOOST_ASIO_OS_DEF(AF_INET6):
3063 if (salen != sizeof(sockaddr_in6_type))
3064 {
3065 return ec = boost::asio::error::invalid_argument;
3066 }
3067 addr = reinterpret_cast<const char*>(
3068 &reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_addr);
3069 addr_len = sizeof(in6_addr_type);
3070 port = reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_port;
3071 break;
3072 default:
3073 return ec = boost::asio::error::address_family_not_supported;
3074 }
3075
3076 if (host && hostlen > 0)
3077 {
3078 if (flags & NI_NUMERICHOST)
3079 {
3080 if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen, 0, ec) == 0)
3081 {
3082 return ec;
3083 }
3084 }
3085 else
3086 {
3087 hostent hent;
3088 char hbuf[8192] = "";
3089 hostent* hptr = socket_ops::gethostbyaddr(addr,
3090 static_cast<int>(addr_len), sa->sa_family,
3091 &hent, hbuf, sizeof(hbuf), ec);
3092 if (hptr && hptr->h_name && hptr->h_name[0] != '\0')
3093 {
3094 if (flags & NI_NOFQDN)
3095 {
3096 char* dot = strchr(hptr->h_name, '.');
3097 if (dot)
3098 {
3099 *dot = 0;
3100 }
3101 }
3102 gai_strcpy(host, hptr->h_name, hostlen);
3103 socket_ops::freehostent(hptr);
3104 }
3105 else
3106 {
3107 socket_ops::freehostent(hptr);
3108 if (flags & NI_NAMEREQD)
3109 {
3110 return ec = boost::asio::error::host_not_found;
3111 }
3112 if (socket_ops::inet_ntop(sa->sa_family,
3113 addr, host, hostlen, 0, ec) == 0)
3114 {
3115 return ec;
3116 }
3117 }
3118 }
3119 }
3120
3121 if (serv && servlen > 0)
3122 {
3123 if (flags & NI_NUMERICSERV)
3124 {
3125 if (servlen < 6)
3126 {
3127 return ec = boost::asio::error::no_buffer_space;
3128 }
3129#if defined(BOOST_ASIO_HAS_SECURE_RTL)
3130 sprintf_s(serv, servlen, "%u", ntohs(port));
3131#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
3132 sprintf(serv, "%u", ntohs(port));
3133#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
3134 }
3135 else
3136 {
3137#if defined(BOOST_ASIO_HAS_PTHREADS)
3138 static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
3139 ::pthread_mutex_lock(&mutex);
3140#endif // defined(BOOST_ASIO_HAS_PTHREADS)
3141 servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0);
3142 if (sptr && sptr->s_name && sptr->s_name[0] != '\0')
3143 {
3144 gai_strcpy(serv, sptr->s_name, servlen);
3145 }
3146 else
3147 {
3148 if (servlen < 6)
3149 {
3150 return ec = boost::asio::error::no_buffer_space;
3151 }
3152#if defined(BOOST_ASIO_HAS_SECURE_RTL)
3153 sprintf_s(serv, servlen, "%u", ntohs(port));
3154#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
3155 sprintf(serv, "%u", ntohs(port));
3156#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
3157 }
3158#if defined(BOOST_ASIO_HAS_PTHREADS)
3159 ::pthread_mutex_unlock(&mutex);
3160#endif // defined(BOOST_ASIO_HAS_PTHREADS)
3161 }
3162 }
3163
3164 ec = boost::system::error_code();
3165 return ec;
3166}
3167
3168#endif // !defined(BOOST_ASIO_HAS_GETADDRINFO)
3169
3170inline boost::system::error_code translate_addrinfo_error(int error)
3171{
3172 switch (error)
3173 {
3174 case 0:
3175 return boost::system::error_code();
3176 case EAI_AGAIN:
3177 return boost::asio::error::host_not_found_try_again;
3178 case EAI_BADFLAGS:
3179 return boost::asio::error::invalid_argument;
3180 case EAI_FAIL:
3181 return boost::asio::error::no_recovery;
3182 case EAI_FAMILY:
3183 return boost::asio::error::address_family_not_supported;
3184 case EAI_MEMORY:
3185 return boost::asio::error::no_memory;
3186 case EAI_NONAME:
3187#if defined(EAI_ADDRFAMILY)
3188 case EAI_ADDRFAMILY:
3189#endif
3190#if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME)
3191 case EAI_NODATA:
3192#endif
3193 return boost::asio::error::host_not_found;
3194 case EAI_SERVICE:
3195 return boost::asio::error::service_not_found;
3196 case EAI_SOCKTYPE:
3197 return boost::asio::error::socket_type_not_supported;
3198 default: // Possibly the non-portable EAI_SYSTEM.
3199#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
3200 return boost::system::error_code(
3201 WSAGetLastError(), boost::asio::error::get_system_category());
3202#else
3203 return boost::system::error_code(
3204 errno, boost::asio::error::get_system_category());
3205#endif
3206 }
3207}
3208
3209boost::system::error_code getaddrinfo(const char* host,
3210 const char* service, const addrinfo_type& hints,
3211 addrinfo_type** result, boost::system::error_code& ec)
3212{
3213 host = (host && *host) ? host : 0;
3214 service = (service && *service) ? service : 0;
3215 clear_last_error();
3216#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
3217# if defined(BOOST_ASIO_HAS_GETADDRINFO)
3218 // Building for Windows XP, Windows Server 2003, or later.
3219 int error = ::getaddrinfo(host, service, &hints, result);
3220 return ec = translate_addrinfo_error(error);
3221# else
3222 // Building for Windows 2000 or earlier.
3223 typedef int (WSAAPI *gai_t)(const char*,
3224 const char*, const addrinfo_type*, addrinfo_type**);
3225 if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
3226 {
3227 if (gai_t gai = (gai_t)::GetProcAddress(winsock_module, "getaddrinfo"))
3228 {
3229 int error = gai(host, service, &hints, result);
3230 return ec = translate_addrinfo_error(error);
3231 }
3232 }
3233 int error = getaddrinfo_emulation(host, service, &hints, result);
3234 return ec = translate_addrinfo_error(error);
3235# endif
3236#elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
3237 int error = getaddrinfo_emulation(host, service, &hints, result);
3238 return ec = translate_addrinfo_error(error);
3239#else
3240 int error = ::getaddrinfo(host, service, &hints, result);
3241 return ec = translate_addrinfo_error(error);
3242#endif
3243}
3244
3245boost::system::error_code background_getaddrinfo(
3246 const weak_cancel_token_type& cancel_token, const char* host,
3247 const char* service, const addrinfo_type& hints,
3248 addrinfo_type** result, boost::system::error_code& ec)
3249{
3250 if (cancel_token.expired())
3251 ec = boost::asio::error::operation_aborted;
3252 else
3253 socket_ops::getaddrinfo(host, service, hints, result, ec);
3254 return ec;
3255}
3256
3257void freeaddrinfo(addrinfo_type* ai)
3258{
3259#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
3260# if defined(BOOST_ASIO_HAS_GETADDRINFO)
3261 // Building for Windows XP, Windows Server 2003, or later.
3262 ::freeaddrinfo(ai);
3263# else
3264 // Building for Windows 2000 or earlier.
3265 typedef int (WSAAPI *fai_t)(addrinfo_type*);
3266 if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
3267 {
3268 if (fai_t fai = (fai_t)::GetProcAddress(winsock_module, "freeaddrinfo"))
3269 {
3270 fai(ai);
3271 return;
3272 }
3273 }
3274 freeaddrinfo_emulation(ai);
3275# endif
3276#elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
3277 freeaddrinfo_emulation(ai);
3278#else
3279 ::freeaddrinfo(ai);
3280#endif
3281}
3282
3283boost::system::error_code getnameinfo(const socket_addr_type* addr,
3284 std::size_t addrlen, char* host, std::size_t hostlen,
3285 char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
3286{
3287#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
3288# if defined(BOOST_ASIO_HAS_GETADDRINFO)
3289 // Building for Windows XP, Windows Server 2003, or later.
3290 clear_last_error();
3291 int error = ::getnameinfo(addr, static_cast<socklen_t>(addrlen),
3292 host, static_cast<DWORD>(hostlen),
3293 serv, static_cast<DWORD>(servlen), flags);
3294 return ec = translate_addrinfo_error(error);
3295# else
3296 // Building for Windows 2000 or earlier.
3297 typedef int (WSAAPI *gni_t)(const socket_addr_type*,
3298 int, char*, DWORD, char*, DWORD, int);
3299 if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
3300 {
3301 if (gni_t gni = (gni_t)::GetProcAddress(winsock_module, "getnameinfo"))
3302 {
3303 clear_last_error();
3304 int error = gni(addr, static_cast<int>(addrlen),
3305 host, static_cast<DWORD>(hostlen),
3306 serv, static_cast<DWORD>(servlen), flags);
3307 return ec = translate_addrinfo_error(error);
3308 }
3309 }
3310 clear_last_error();
3311 return getnameinfo_emulation(addr, addrlen,
3312 host, hostlen, serv, servlen, flags, ec);
3313# endif
3314#elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
3315 using namespace std; // For memcpy.
3316 sockaddr_storage_type tmp_addr;
3317 memcpy(&tmp_addr, addr, addrlen);
3318 tmp_addr.ss_len = addrlen;
3319 addr = reinterpret_cast<socket_addr_type*>(&tmp_addr);
3320 clear_last_error();
3321 return getnameinfo_emulation(addr, addrlen,
3322 host, hostlen, serv, servlen, flags, ec);
3323#else
3324 clear_last_error();
3325 int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
3326 return ec = translate_addrinfo_error(error);
3327#endif
3328}
3329
3330boost::system::error_code sync_getnameinfo(
3331 const socket_addr_type* addr, std::size_t addrlen,
3332 char* host, std::size_t hostlen, char* serv,
3333 std::size_t servlen, int sock_type, boost::system::error_code& ec)
3334{
3335 // First try resolving with the service name. If that fails try resolving
3336 // but allow the service to be returned as a number.
3337 int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0;
3338 socket_ops::getnameinfo(addr, addrlen, host,
3339 hostlen, serv, servlen, flags, ec);
3340 if (ec)
3341 {
3342 socket_ops::getnameinfo(addr, addrlen, host, hostlen,
3343 serv, servlen, flags | NI_NUMERICSERV, ec);
3344 }
3345
3346 return ec;
3347}
3348
3349boost::system::error_code background_getnameinfo(
3350 const weak_cancel_token_type& cancel_token,
3351 const socket_addr_type* addr, std::size_t addrlen,
3352 char* host, std::size_t hostlen, char* serv,
3353 std::size_t servlen, int sock_type, boost::system::error_code& ec)
3354{
3355 if (cancel_token.expired())
3356 {
3357 ec = boost::asio::error::operation_aborted;
3358 }
3359 else
3360 {
3361 // First try resolving with the service name. If that fails try resolving
3362 // but allow the service to be returned as a number.
3363 int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0;
3364 socket_ops::getnameinfo(addr, addrlen, host,
3365 hostlen, serv, servlen, flags, ec);
3366 if (ec)
3367 {
3368 socket_ops::getnameinfo(addr, addrlen, host, hostlen,
3369 serv, servlen, flags | NI_NUMERICSERV, ec);
3370 }
3371 }
3372
3373 return ec;
3374}
3375
3376#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
3377
3378u_long_type network_to_host_long(u_long_type value)
3379{
3380#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
3381 unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
3382 u_long_type result = (static_cast<u_long_type>(value_p[0]) << 24)
3383 | (static_cast<u_long_type>(value_p[1]) << 16)
3384 | (static_cast<u_long_type>(value_p[2]) << 8)
3385 | static_cast<u_long_type>(value_p[3]);
3386 return result;
3387#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3388 return ntohl(value);
3389#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3390}
3391
3392u_long_type host_to_network_long(u_long_type value)
3393{
3394#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
3395 u_long_type result;
3396 unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
3397 result_p[0] = static_cast<unsigned char>((value >> 24) & 0xFF);
3398 result_p[1] = static_cast<unsigned char>((value >> 16) & 0xFF);
3399 result_p[2] = static_cast<unsigned char>((value >> 8) & 0xFF);
3400 result_p[3] = static_cast<unsigned char>(value & 0xFF);
3401 return result;
3402#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3403 return htonl(value);
3404#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3405}
3406
3407u_short_type network_to_host_short(u_short_type value)
3408{
3409#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
3410 unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
3411 u_short_type result = (static_cast<u_short_type>(value_p[0]) << 8)
3412 | static_cast<u_short_type>(value_p[1]);
3413 return result;
3414#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3415 return ntohs(value);
3416#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3417}
3418
3419u_short_type host_to_network_short(u_short_type value)
3420{
3421#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
3422 u_short_type result;
3423 unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
3424 result_p[0] = static_cast<unsigned char>((value >> 8) & 0xFF);
3425 result_p[1] = static_cast<unsigned char>(value & 0xFF);
3426 return result;
3427#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3428 return htons(value);
3429#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
3430}
3431
3432} // namespace socket_ops
3433} // namespace detail
3434} // namespace asio
3435} // namespace boost
3436
3437#include <boost/asio/detail/pop_options.hpp>
3438
3439#endif // BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
3440