mirror of
https://github.com/boostorg/asio.git
synced 2026-01-27 18:42:07 +00:00
68a7cd26a6
------------------------------------------------------------------------ r85735 | chris_kohlhoff | 2013-09-18 07:31:55 +1000 (Wed, 18 Sep 2013) | 1 line Remove dependency on Boost.Preprocessor library. ------------------------------------------------------------------------ r85736 | chris_kohlhoff | 2013-09-18 07:32:48 +1000 (Wed, 18 Sep 2013) | 1 line Fix error in async_receive_from example. ------------------------------------------------------------------------ r85737 | chris_kohlhoff | 2013-09-18 07:33:39 +1000 (Wed, 18 Sep 2013) | 1 line Remove unused variable assignment. ------------------------------------------------------------------------ r85738 | chris_kohlhoff | 2013-09-18 07:35:43 +1000 (Wed, 18 Sep 2013) | 3 lines Fix a regression where, on some platforms, errors from async_connect are not correctly propagated through to the completion handler. ------------------------------------------------------------------------ r85739 | chris_kohlhoff | 2013-09-18 07:36:54 +1000 (Wed, 18 Sep 2013) | 1 line Remove unused parameters and member variables. ------------------------------------------------------------------------ r85740 | chris_kohlhoff | 2013-09-18 07:38:41 +1000 (Wed, 18 Sep 2013) | 1 line Fix nfds argument to select. ------------------------------------------------------------------------ r85741 | chris_kohlhoff | 2013-09-18 07:39:38 +1000 (Wed, 18 Sep 2013) | 1 line Fix a regression on Windows where multiple threads are running an io_service. ------------------------------------------------------------------------ r85742 | chris_kohlhoff | 2013-09-18 07:40:19 +1000 (Wed, 18 Sep 2013) | 1 line Fix typo in serial ports overview. ------------------------------------------------------------------------ r85743 | chris_kohlhoff | 2013-09-18 07:41:04 +1000 (Wed, 18 Sep 2013) | 1 line Ensure ssl::io_op::want_ member is initialised. ------------------------------------------------------------------------ r85744 | chris_kohlhoff | 2013-09-18 07:42:08 +1000 (Wed, 18 Sep 2013) | 1 line Fix a bug in handler tracking, where it was not correctly printing out some handler IDs. ------------------------------------------------------------------------ r85745 | chris_kohlhoff | 2013-09-18 07:42:48 +1000 (Wed, 18 Sep 2013) | 1 line Fix comparison used to test for a successful synchronous accept. ------------------------------------------------------------------------ r85746 | chris_kohlhoff | 2013-09-18 07:43:29 +1000 (Wed, 18 Sep 2013) | 3 lines Ensure signal number is correctly passed to the completion handler when starting an async_wait on a signal that is already raised. ------------------------------------------------------------------------ r85747 | chris_kohlhoff | 2013-09-18 07:45:43 +1000 (Wed, 18 Sep 2013) | 1 line Suppress g++ 4.8+ warning about unused typedefs. ------------------------------------------------------------------------ r85748 | chris_kohlhoff | 2013-09-18 07:48:54 +1000 (Wed, 18 Sep 2013) | 1 line Fix link to refer to native_handle() rather than the deprecated native() function. ------------------------------------------------------------------------ r85749 | chris_kohlhoff | 2013-09-18 07:51:28 +1000 (Wed, 18 Sep 2013) | 3 lines Enable the move optimisation (and otherwise eliminate a copy) for handlers using the default invocation hook. ------------------------------------------------------------------------ r85750 | chris_kohlhoff | 2013-09-18 07:52:27 +1000 (Wed, 18 Sep 2013) | 2 lines Clarify that programs must not issue overlapping async_write_at operations. ------------------------------------------------------------------------ r85751 | chris_kohlhoff | 2013-09-18 07:53:03 +1000 (Wed, 18 Sep 2013) | 1 line Fix error in comment. ------------------------------------------------------------------------ r85752 | chris_kohlhoff | 2013-09-18 07:53:45 +1000 (Wed, 18 Sep 2013) | 1 line Remove spurious whitespace. ------------------------------------------------------------------------ r85753 | chris_kohlhoff | 2013-09-18 08:00:53 +1000 (Wed, 18 Sep 2013) | 2 lines Clean up some internal forward declarations. ------------------------------------------------------------------------ r85754 | chris_kohlhoff | 2013-09-18 08:01:26 +1000 (Wed, 18 Sep 2013) | 1 line Add missing move cast. ------------------------------------------------------------------------ r85755 | chris_kohlhoff | 2013-09-18 08:03:29 +1000 (Wed, 18 Sep 2013) | 3 lines Fix another socket descriptor comparison that doesn't work correctly if the descriptor type is unsigned. ------------------------------------------------------------------------ r85756 | chris_kohlhoff | 2013-09-18 08:04:10 +1000 (Wed, 18 Sep 2013) | 3 lines Fix documentation error where an asynchronous function was described as having synchronous behaviour. ------------------------------------------------------------------------ r85757 | chris_kohlhoff | 2013-09-18 08:04:55 +1000 (Wed, 18 Sep 2013) | 1 line Add missing forward declarations needed for Windows. ------------------------------------------------------------------------ r85758 | chris_kohlhoff | 2013-09-18 08:05:38 +1000 (Wed, 18 Sep 2013) | 1 line Remove use of std::min. ------------------------------------------------------------------------ r85759 | chris_kohlhoff | 2013-09-18 08:06:25 +1000 (Wed, 18 Sep 2013) | 3 lines Inore ERROR_MORE_DATA as a non-fatal error when returned by GetOverlappedResult for a synchronous read. ------------------------------------------------------------------------ r85760 | chris_kohlhoff | 2013-09-18 08:08:07 +1000 (Wed, 18 Sep 2013) | 2 lines Enable certain C++11 standard library facilities for recent versions of Microsoft Visual Studio. ------------------------------------------------------------------------ r85761 | chris_kohlhoff | 2013-09-18 08:08:43 +1000 (Wed, 18 Sep 2013) | 4 lines Visual C++ language extensions use generic as a keyword. Add a workaround that renames the namespace to cpp_generic when those language extensions are in effect. ------------------------------------------------------------------------ r85762 | chris_kohlhoff | 2013-09-18 08:12:07 +1000 (Wed, 18 Sep 2013) | 2 lines Some async operations that missed getting the async_result treatment. ------------------------------------------------------------------------ r85763 | chris_kohlhoff | 2013-09-18 08:14:14 +1000 (Wed, 18 Sep 2013) | 2 lines Eliminate some unnecessary handler copies. ------------------------------------------------------------------------ r85764 | chris_kohlhoff | 2013-09-18 08:24:19 +1000 (Wed, 18 Sep 2013) | 26 lines Initial port to Windows Runtime. This change adds limited support for using Asio with the Windows Runtime. It requires that the language extensions be enabled. Due to the restricted facilities exposed by the Windows Runtime API, the port comes with the following caveats: * The core facilities such as the io_service, strand, buffers, composed operations, timers, etc., should all work as normal. * For sockets, only client-side TCP is supported. * Explicit binding of a client-side TCP socket is not supported. * The cancel() function is not supported for sockets. Asynchronous operations may only be cancelled by closing the socket. * Operations that use null_buffers are not supported. * Only tcp::no_delay and socket_base::keep_alive options are supported. * Resolvers do not support service names, only numbers. I.e. you must use 80 rather than http. * Most resolver query flags have no effect. ------------------------------------------------------------------------ r85765 | chris_kohlhoff | 2013-09-18 08:32:13 +1000 (Wed, 18 Sep 2013) | 1 line Regenerate documentation. ------------------------------------------------------------------------ r85766 | chris_kohlhoff | 2013-09-18 08:38:04 +1000 (Wed, 18 Sep 2013) | 2 lines Enable move support for Microsoft Visual C++ 2012. ------------------------------------------------------------------------ r85767 | chris_kohlhoff | 2013-09-18 08:42:50 +1000 (Wed, 18 Sep 2013) | 2 lines Add use_future support for Microsoft Visual C++. ------------------------------------------------------------------------ r85768 | chris_kohlhoff | 2013-09-18 08:53:17 +1000 (Wed, 18 Sep 2013) | 2 lines Fix prefix on extern "C" function name. ------------------------------------------------------------------------ r85781 | chris_kohlhoff | 2013-09-19 08:43:01 +1000 (Thu, 19 Sep 2013) | 1 line Implement end-of-file condition for WinRT stream sockets. ------------------------------------------------------------------------ r85798 | chris_kohlhoff | 2013-09-20 22:00:44 +1000 (Fri, 20 Sep 2013) | 2 lines Update buffered stream operations to adhere to current handler patterns. ------------------------------------------------------------------------ r85799 | chris_kohlhoff | 2013-09-20 22:02:33 +1000 (Fri, 20 Sep 2013) | 1 line MinGW fix. ------------------------------------------------------------------------ r85800 | chris_kohlhoff | 2013-09-20 22:04:00 +1000 (Fri, 20 Sep 2013) | 1 line Change unit tests so that they don't depend on Boost.Thread. ------------------------------------------------------------------------ r85801 | chris_kohlhoff | 2013-09-20 22:10:45 +1000 (Fri, 20 Sep 2013) | 1 line Regenerate documentation. ------------------------------------------------------------------------ r85823 | danieljames | 2013-09-22 20:32:36 +1000 (Sun, 22 Sep 2013) | 1 line Fix copying C++11 allocation examples ------------------------------------------------------------------------ [SVN r85838]
540 lines
19 KiB
C++
540 lines
19 KiB
C++
//
|
|
// udp.cpp
|
|
// ~~~~~~~
|
|
//
|
|
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
|
|
// Disable autolinking for unit tests.
|
|
#if !defined(BOOST_ALL_NO_LIB)
|
|
#define BOOST_ALL_NO_LIB 1
|
|
#endif // !defined(BOOST_ALL_NO_LIB)
|
|
|
|
// Test that header file is self-contained.
|
|
#include <boost/asio/ip/udp.hpp>
|
|
|
|
#include <cstring>
|
|
#include <boost/asio/io_service.hpp>
|
|
#include "../unit_test.hpp"
|
|
#include "../archetypes/gettable_socket_option.hpp"
|
|
#include "../archetypes/async_result.hpp"
|
|
#include "../archetypes/io_control_command.hpp"
|
|
#include "../archetypes/settable_socket_option.hpp"
|
|
|
|
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
|
|
# include <boost/bind.hpp>
|
|
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
|
|
# include <functional>
|
|
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// ip_udp_socket_compile test
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// The following test checks that all public member functions on the class
|
|
// ip::udp::socket compile and link correctly. Runtime failures are ignored.
|
|
|
|
namespace ip_udp_socket_compile {
|
|
|
|
void connect_handler(const boost::system::error_code&)
|
|
{
|
|
}
|
|
|
|
void send_handler(const boost::system::error_code&, std::size_t)
|
|
{
|
|
}
|
|
|
|
void receive_handler(const boost::system::error_code&, std::size_t)
|
|
{
|
|
}
|
|
|
|
void test()
|
|
{
|
|
using namespace boost::asio;
|
|
namespace ip = boost::asio::ip;
|
|
|
|
try
|
|
{
|
|
io_service ios;
|
|
char mutable_char_buffer[128] = "";
|
|
const char const_char_buffer[128] = "";
|
|
socket_base::message_flags in_flags = 0;
|
|
archetypes::settable_socket_option<void> settable_socket_option1;
|
|
archetypes::settable_socket_option<int> settable_socket_option2;
|
|
archetypes::settable_socket_option<double> settable_socket_option3;
|
|
archetypes::gettable_socket_option<void> gettable_socket_option1;
|
|
archetypes::gettable_socket_option<int> gettable_socket_option2;
|
|
archetypes::gettable_socket_option<double> gettable_socket_option3;
|
|
archetypes::io_control_command io_control_command;
|
|
archetypes::lazy_handler lazy;
|
|
boost::system::error_code ec;
|
|
|
|
// basic_datagram_socket constructors.
|
|
|
|
ip::udp::socket socket1(ios);
|
|
ip::udp::socket socket2(ios, ip::udp::v4());
|
|
ip::udp::socket socket3(ios, ip::udp::v6());
|
|
ip::udp::socket socket4(ios, ip::udp::endpoint(ip::udp::v4(), 0));
|
|
ip::udp::socket socket5(ios, ip::udp::endpoint(ip::udp::v6(), 0));
|
|
#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
|
|
int native_socket1 = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
ip::udp::socket socket6(ios, ip::udp::v4(), native_socket1);
|
|
#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
|
|
|
|
#if defined(BOOST_ASIO_HAS_MOVE)
|
|
ip::udp::socket socket7(std::move(socket6));
|
|
#endif // defined(BOOST_ASIO_HAS_MOVE)
|
|
|
|
// basic_datagram_socket operators.
|
|
|
|
#if defined(BOOST_ASIO_HAS_MOVE)
|
|
socket1 = ip::udp::socket(ios);
|
|
socket1 = std::move(socket2);
|
|
#endif // defined(BOOST_ASIO_HAS_MOVE)
|
|
|
|
// basic_io_object functions.
|
|
|
|
io_service& ios_ref = socket1.get_io_service();
|
|
(void)ios_ref;
|
|
|
|
// basic_socket functions.
|
|
|
|
ip::udp::socket::lowest_layer_type& lowest_layer = socket1.lowest_layer();
|
|
(void)lowest_layer;
|
|
|
|
const ip::udp::socket& socket8 = socket1;
|
|
const ip::udp::socket::lowest_layer_type& lowest_layer2
|
|
= socket8.lowest_layer();
|
|
(void)lowest_layer2;
|
|
|
|
socket1.open(ip::udp::v4());
|
|
socket1.open(ip::udp::v6());
|
|
socket1.open(ip::udp::v4(), ec);
|
|
socket1.open(ip::udp::v6(), ec);
|
|
|
|
#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
|
|
int native_socket2 = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
socket1.assign(ip::udp::v4(), native_socket2);
|
|
int native_socket3 = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
socket1.assign(ip::udp::v4(), native_socket3, ec);
|
|
#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
|
|
|
|
bool is_open = socket1.is_open();
|
|
(void)is_open;
|
|
|
|
socket1.close();
|
|
socket1.close(ec);
|
|
|
|
ip::udp::socket::native_type native_socket4 = socket1.native();
|
|
(void)native_socket4;
|
|
|
|
ip::udp::socket::native_handle_type native_socket5
|
|
= socket1.native_handle();
|
|
(void)native_socket5;
|
|
|
|
socket1.cancel();
|
|
socket1.cancel(ec);
|
|
|
|
bool at_mark1 = socket1.at_mark();
|
|
(void)at_mark1;
|
|
bool at_mark2 = socket1.at_mark(ec);
|
|
(void)at_mark2;
|
|
|
|
std::size_t available1 = socket1.available();
|
|
(void)available1;
|
|
std::size_t available2 = socket1.available(ec);
|
|
(void)available2;
|
|
|
|
socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0));
|
|
socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0));
|
|
socket1.bind(ip::udp::endpoint(ip::udp::v4(), 0), ec);
|
|
socket1.bind(ip::udp::endpoint(ip::udp::v6(), 0), ec);
|
|
|
|
socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0));
|
|
socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0));
|
|
socket1.connect(ip::udp::endpoint(ip::udp::v4(), 0), ec);
|
|
socket1.connect(ip::udp::endpoint(ip::udp::v6(), 0), ec);
|
|
|
|
socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0),
|
|
&connect_handler);
|
|
socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0),
|
|
&connect_handler);
|
|
int i1 = socket1.async_connect(ip::udp::endpoint(ip::udp::v4(), 0), lazy);
|
|
(void)i1;
|
|
int i2 = socket1.async_connect(ip::udp::endpoint(ip::udp::v6(), 0), lazy);
|
|
(void)i2;
|
|
|
|
socket1.set_option(settable_socket_option1);
|
|
socket1.set_option(settable_socket_option1, ec);
|
|
socket1.set_option(settable_socket_option2);
|
|
socket1.set_option(settable_socket_option2, ec);
|
|
socket1.set_option(settable_socket_option3);
|
|
socket1.set_option(settable_socket_option3, ec);
|
|
|
|
socket1.get_option(gettable_socket_option1);
|
|
socket1.get_option(gettable_socket_option1, ec);
|
|
socket1.get_option(gettable_socket_option2);
|
|
socket1.get_option(gettable_socket_option2, ec);
|
|
socket1.get_option(gettable_socket_option3);
|
|
socket1.get_option(gettable_socket_option3, ec);
|
|
|
|
socket1.io_control(io_control_command);
|
|
socket1.io_control(io_control_command, ec);
|
|
|
|
bool non_blocking1 = socket1.non_blocking();
|
|
(void)non_blocking1;
|
|
socket1.non_blocking(true);
|
|
socket1.non_blocking(false, ec);
|
|
|
|
bool non_blocking2 = socket1.native_non_blocking();
|
|
(void)non_blocking2;
|
|
socket1.native_non_blocking(true);
|
|
socket1.native_non_blocking(false, ec);
|
|
|
|
ip::udp::endpoint endpoint1 = socket1.local_endpoint();
|
|
ip::udp::endpoint endpoint2 = socket1.local_endpoint(ec);
|
|
|
|
ip::udp::endpoint endpoint3 = socket1.remote_endpoint();
|
|
ip::udp::endpoint endpoint4 = socket1.remote_endpoint(ec);
|
|
|
|
socket1.shutdown(socket_base::shutdown_both);
|
|
socket1.shutdown(socket_base::shutdown_both, ec);
|
|
|
|
// basic_datagram_socket functions.
|
|
|
|
socket1.send(buffer(mutable_char_buffer));
|
|
socket1.send(buffer(const_char_buffer));
|
|
socket1.send(null_buffers());
|
|
socket1.send(buffer(mutable_char_buffer), in_flags);
|
|
socket1.send(buffer(const_char_buffer), in_flags);
|
|
socket1.send(null_buffers(), in_flags);
|
|
socket1.send(buffer(mutable_char_buffer), in_flags, ec);
|
|
socket1.send(buffer(const_char_buffer), in_flags, ec);
|
|
socket1.send(null_buffers(), in_flags, ec);
|
|
|
|
socket1.async_send(buffer(mutable_char_buffer), &send_handler);
|
|
socket1.async_send(buffer(const_char_buffer), &send_handler);
|
|
socket1.async_send(null_buffers(), &send_handler);
|
|
socket1.async_send(buffer(mutable_char_buffer), in_flags, &send_handler);
|
|
socket1.async_send(buffer(const_char_buffer), in_flags, &send_handler);
|
|
socket1.async_send(null_buffers(), in_flags, &send_handler);
|
|
int i3 = socket1.async_send(buffer(mutable_char_buffer), lazy);
|
|
(void)i3;
|
|
int i4 = socket1.async_send(buffer(const_char_buffer), lazy);
|
|
(void)i4;
|
|
int i5 = socket1.async_send(null_buffers(), lazy);
|
|
(void)i5;
|
|
int i6 = socket1.async_send(buffer(mutable_char_buffer), in_flags, lazy);
|
|
(void)i6;
|
|
int i7 = socket1.async_send(buffer(const_char_buffer), in_flags, lazy);
|
|
(void)i7;
|
|
int i8 = socket1.async_send(null_buffers(), in_flags, lazy);
|
|
(void)i8;
|
|
|
|
socket1.send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0));
|
|
socket1.send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0));
|
|
socket1.send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0));
|
|
socket1.send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0));
|
|
socket1.send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0));
|
|
socket1.send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0));
|
|
socket1.send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
|
|
socket1.send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
|
|
socket1.send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
|
|
socket1.send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
|
|
socket1.send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags);
|
|
socket1.send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags);
|
|
socket1.send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
|
|
socket1.send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
|
|
socket1.send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
|
|
socket1.send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
|
|
socket1.send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, ec);
|
|
socket1.send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, ec);
|
|
|
|
socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), &send_handler);
|
|
socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), &send_handler);
|
|
socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), &send_handler);
|
|
socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), &send_handler);
|
|
socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), &send_handler);
|
|
socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), &send_handler);
|
|
socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, &send_handler);
|
|
socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, &send_handler);
|
|
socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, &send_handler);
|
|
socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, &send_handler);
|
|
socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, &send_handler);
|
|
socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, &send_handler);
|
|
int i9 = socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), lazy);
|
|
(void)i9;
|
|
int i10 = socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), lazy);
|
|
(void)i10;
|
|
int i11 = socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), lazy);
|
|
(void)i11;
|
|
int i12 = socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), lazy);
|
|
(void)i12;
|
|
int i13 = socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), lazy);
|
|
(void)i13;
|
|
int i14 = socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), lazy);
|
|
(void)i14;
|
|
int i15 = socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
|
|
(void)i15;
|
|
int i16 = socket1.async_send_to(buffer(mutable_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
|
|
(void)i16;
|
|
int i17 = socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
|
|
(void)i17;
|
|
int i18 = socket1.async_send_to(buffer(const_char_buffer),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
|
|
(void)i18;
|
|
int i19 = socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v4(), 0), in_flags, lazy);
|
|
(void)i19;
|
|
int i20 = socket1.async_send_to(null_buffers(),
|
|
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
|
|
(void)i20;
|
|
|
|
socket1.receive(buffer(mutable_char_buffer));
|
|
socket1.receive(null_buffers());
|
|
socket1.receive(buffer(mutable_char_buffer), in_flags);
|
|
socket1.receive(null_buffers(), in_flags);
|
|
socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
|
|
socket1.receive(null_buffers(), in_flags, ec);
|
|
|
|
socket1.async_receive(buffer(mutable_char_buffer), &receive_handler);
|
|
socket1.async_receive(null_buffers(), &receive_handler);
|
|
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
|
|
&receive_handler);
|
|
socket1.async_receive(null_buffers(), in_flags, &receive_handler);
|
|
int i21 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
|
|
(void)i21;
|
|
int i22 = socket1.async_receive(null_buffers(), lazy);
|
|
(void)i22;
|
|
int i23 = socket1.async_receive(buffer(mutable_char_buffer),
|
|
in_flags, lazy);
|
|
(void)i23;
|
|
int i24 = socket1.async_receive(null_buffers(), in_flags, lazy);
|
|
(void)i24;
|
|
|
|
ip::udp::endpoint endpoint;
|
|
socket1.receive_from(buffer(mutable_char_buffer), endpoint);
|
|
socket1.receive_from(null_buffers(), endpoint);
|
|
socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
|
|
socket1.receive_from(null_buffers(), endpoint, in_flags);
|
|
socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
|
|
socket1.receive_from(null_buffers(), endpoint, in_flags, ec);
|
|
|
|
socket1.async_receive_from(buffer(mutable_char_buffer),
|
|
endpoint, &receive_handler);
|
|
socket1.async_receive_from(null_buffers(),
|
|
endpoint, &receive_handler);
|
|
socket1.async_receive_from(buffer(mutable_char_buffer),
|
|
endpoint, in_flags, &receive_handler);
|
|
socket1.async_receive_from(null_buffers(),
|
|
endpoint, in_flags, &receive_handler);
|
|
int i25 = socket1.async_receive_from(buffer(mutable_char_buffer),
|
|
endpoint, lazy);
|
|
(void)i25;
|
|
int i26 = socket1.async_receive_from(null_buffers(),
|
|
endpoint, lazy);
|
|
(void)i26;
|
|
int i27 = socket1.async_receive_from(buffer(mutable_char_buffer),
|
|
endpoint, in_flags, lazy);
|
|
(void)i27;
|
|
int i28 = socket1.async_receive_from(null_buffers(),
|
|
endpoint, in_flags, lazy);
|
|
(void)i28;
|
|
}
|
|
catch (std::exception&)
|
|
{
|
|
}
|
|
}
|
|
|
|
} // namespace ip_udp_socket_compile
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// ip_udp_socket_runtime test
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// The following test checks the runtime operation of the ip::udp::socket class.
|
|
|
|
namespace ip_udp_socket_runtime {
|
|
|
|
void handle_send(size_t expected_bytes_sent,
|
|
const boost::system::error_code& err, size_t bytes_sent)
|
|
{
|
|
BOOST_ASIO_CHECK(!err);
|
|
BOOST_ASIO_CHECK(expected_bytes_sent == bytes_sent);
|
|
}
|
|
|
|
void handle_recv(size_t expected_bytes_recvd,
|
|
const boost::system::error_code& err, size_t bytes_recvd)
|
|
{
|
|
BOOST_ASIO_CHECK(!err);
|
|
BOOST_ASIO_CHECK(expected_bytes_recvd == bytes_recvd);
|
|
}
|
|
|
|
void test()
|
|
{
|
|
using namespace std; // For memcmp and memset.
|
|
using namespace boost::asio;
|
|
namespace ip = boost::asio::ip;
|
|
|
|
#if defined(BOOST_ASIO_HAS_BOOST_BIND)
|
|
namespace bindns = boost;
|
|
#else // defined(BOOST_ASIO_HAS_BOOST_BIND)
|
|
namespace bindns = std;
|
|
using std::placeholders::_1;
|
|
using std::placeholders::_2;
|
|
#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
|
|
|
|
io_service ios;
|
|
|
|
ip::udp::socket s1(ios, ip::udp::endpoint(ip::udp::v4(), 0));
|
|
ip::udp::endpoint target_endpoint = s1.local_endpoint();
|
|
target_endpoint.address(ip::address_v4::loopback());
|
|
|
|
ip::udp::socket s2(ios);
|
|
s2.open(ip::udp::v4());
|
|
s2.bind(ip::udp::endpoint(ip::udp::v4(), 0));
|
|
char send_msg[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
|
s2.send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint);
|
|
|
|
char recv_msg[sizeof(send_msg)];
|
|
ip::udp::endpoint sender_endpoint;
|
|
size_t bytes_recvd = s1.receive_from(buffer(recv_msg, sizeof(recv_msg)),
|
|
sender_endpoint);
|
|
|
|
BOOST_ASIO_CHECK(bytes_recvd == sizeof(send_msg));
|
|
BOOST_ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
|
|
|
|
memset(recv_msg, 0, sizeof(recv_msg));
|
|
|
|
target_endpoint = sender_endpoint;
|
|
s1.async_send_to(buffer(send_msg, sizeof(send_msg)), target_endpoint,
|
|
bindns::bind(handle_send, sizeof(send_msg), _1, _2));
|
|
s2.async_receive_from(buffer(recv_msg, sizeof(recv_msg)), sender_endpoint,
|
|
bindns::bind(handle_recv, sizeof(recv_msg), _1, _2));
|
|
|
|
ios.run();
|
|
|
|
BOOST_ASIO_CHECK(memcmp(send_msg, recv_msg, sizeof(send_msg)) == 0);
|
|
}
|
|
|
|
} // namespace ip_udp_socket_runtime
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// ip_udp_resolver_compile test
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// The following test checks that all public member functions on the class
|
|
// ip::udp::resolver compile and link correctly. Runtime failures are ignored.
|
|
|
|
namespace ip_udp_resolver_compile {
|
|
|
|
void resolve_handler(const boost::system::error_code&,
|
|
boost::asio::ip::udp::resolver::iterator)
|
|
{
|
|
}
|
|
|
|
void test()
|
|
{
|
|
using namespace boost::asio;
|
|
namespace ip = boost::asio::ip;
|
|
|
|
try
|
|
{
|
|
io_service ios;
|
|
archetypes::lazy_handler lazy;
|
|
boost::system::error_code ec;
|
|
ip::udp::resolver::query q(ip::udp::v4(), "localhost", "0");
|
|
ip::udp::endpoint e(ip::address_v4::loopback(), 0);
|
|
|
|
// basic_resolver constructors.
|
|
|
|
ip::udp::resolver resolver(ios);
|
|
|
|
// basic_io_object functions.
|
|
|
|
io_service& ios_ref = resolver.get_io_service();
|
|
(void)ios_ref;
|
|
|
|
// basic_resolver functions.
|
|
|
|
resolver.cancel();
|
|
|
|
ip::udp::resolver::iterator iter1 = resolver.resolve(q);
|
|
(void)iter1;
|
|
|
|
ip::udp::resolver::iterator iter2 = resolver.resolve(q, ec);
|
|
(void)iter2;
|
|
|
|
ip::udp::resolver::iterator iter3 = resolver.resolve(e);
|
|
(void)iter3;
|
|
|
|
ip::udp::resolver::iterator iter4 = resolver.resolve(e, ec);
|
|
(void)iter4;
|
|
|
|
resolver.async_resolve(q, &resolve_handler);
|
|
int i1 = resolver.async_resolve(q, lazy);
|
|
(void)i1;
|
|
|
|
resolver.async_resolve(e, &resolve_handler);
|
|
int i2 = resolver.async_resolve(e, lazy);
|
|
(void)i2;
|
|
}
|
|
catch (std::exception&)
|
|
{
|
|
}
|
|
}
|
|
|
|
} // namespace ip_udp_resolver_compile
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
BOOST_ASIO_TEST_SUITE
|
|
(
|
|
"ip/udp",
|
|
BOOST_ASIO_TEST_CASE(ip_udp_socket_compile::test)
|
|
BOOST_ASIO_TEST_CASE(ip_udp_socket_runtime::test)
|
|
BOOST_ASIO_TEST_CASE(ip_udp_resolver_compile::test)
|
|
)
|