]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // basic_raw_socket.hpp | |
3 | // ~~~~~~~~~~~~~~~~~~~~ | |
4 | // | |
b32b8144 | 5 | // Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com) |
7c673cae FG |
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_BASIC_RAW_SOCKET_HPP | |
12 | #define BOOST_ASIO_BASIC_RAW_SOCKET_HPP | |
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 | #include <cstddef> | |
20 | #include <boost/asio/basic_socket.hpp> | |
21 | #include <boost/asio/detail/handler_type_requirements.hpp> | |
22 | #include <boost/asio/detail/throw_error.hpp> | |
23 | #include <boost/asio/detail/type_traits.hpp> | |
24 | #include <boost/asio/error.hpp> | |
b32b8144 FG |
25 | |
26 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
27 | # include <boost/asio/raw_socket_service.hpp> | |
28 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
29 | |
30 | #include <boost/asio/detail/push_options.hpp> | |
31 | ||
32 | namespace boost { | |
33 | namespace asio { | |
34 | ||
35 | /// Provides raw-oriented socket functionality. | |
36 | /** | |
37 | * The basic_raw_socket class template provides asynchronous and blocking | |
38 | * raw-oriented socket functionality. | |
39 | * | |
40 | * @par Thread Safety | |
41 | * @e Distinct @e objects: Safe.@n | |
42 | * @e Shared @e objects: Unsafe. | |
43 | */ | |
b32b8144 FG |
44 | template <typename Protocol |
45 | BOOST_ASIO_SVC_TPARAM_DEF1(= raw_socket_service<Protocol>)> | |
7c673cae | 46 | class basic_raw_socket |
b32b8144 | 47 | : public basic_socket<Protocol BOOST_ASIO_SVC_TARG> |
7c673cae FG |
48 | { |
49 | public: | |
7c673cae | 50 | /// The native representation of a socket. |
b32b8144 FG |
51 | #if defined(GENERATING_DOCUMENTATION) |
52 | typedef implementation_defined native_handle_type; | |
53 | #else | |
54 | typedef typename basic_socket< | |
55 | Protocol BOOST_ASIO_SVC_TARG>::native_handle_type native_handle_type; | |
56 | #endif | |
7c673cae FG |
57 | |
58 | /// The protocol type. | |
59 | typedef Protocol protocol_type; | |
60 | ||
61 | /// The endpoint type. | |
62 | typedef typename Protocol::endpoint endpoint_type; | |
63 | ||
64 | /// Construct a basic_raw_socket without opening it. | |
65 | /** | |
66 | * This constructor creates a raw socket without opening it. The open() | |
67 | * function must be called before data can be sent or received on the socket. | |
68 | * | |
b32b8144 | 69 | * @param io_context The io_context object that the raw socket will use |
7c673cae FG |
70 | * to dispatch handlers for any asynchronous operations performed on the |
71 | * socket. | |
72 | */ | |
b32b8144 FG |
73 | explicit basic_raw_socket(boost::asio::io_context& io_context) |
74 | : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(io_context) | |
7c673cae FG |
75 | { |
76 | } | |
77 | ||
78 | /// Construct and open a basic_raw_socket. | |
79 | /** | |
80 | * This constructor creates and opens a raw socket. | |
81 | * | |
b32b8144 | 82 | * @param io_context The io_context object that the raw socket will use |
7c673cae FG |
83 | * to dispatch handlers for any asynchronous operations performed on the |
84 | * socket. | |
85 | * | |
86 | * @param protocol An object specifying protocol parameters to be used. | |
87 | * | |
88 | * @throws boost::system::system_error Thrown on failure. | |
89 | */ | |
b32b8144 | 90 | basic_raw_socket(boost::asio::io_context& io_context, |
7c673cae | 91 | const protocol_type& protocol) |
b32b8144 | 92 | : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(io_context, protocol) |
7c673cae FG |
93 | { |
94 | } | |
95 | ||
96 | /// Construct a basic_raw_socket, opening it and binding it to the given | |
97 | /// local endpoint. | |
98 | /** | |
99 | * This constructor creates a raw socket and automatically opens it bound | |
100 | * to the specified endpoint on the local machine. The protocol used is the | |
101 | * protocol associated with the given endpoint. | |
102 | * | |
b32b8144 | 103 | * @param io_context The io_context object that the raw socket will use |
7c673cae FG |
104 | * to dispatch handlers for any asynchronous operations performed on the |
105 | * socket. | |
106 | * | |
107 | * @param endpoint An endpoint on the local machine to which the raw | |
108 | * socket will be bound. | |
109 | * | |
110 | * @throws boost::system::system_error Thrown on failure. | |
111 | */ | |
b32b8144 | 112 | basic_raw_socket(boost::asio::io_context& io_context, |
7c673cae | 113 | const endpoint_type& endpoint) |
b32b8144 | 114 | : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(io_context, endpoint) |
7c673cae FG |
115 | { |
116 | } | |
117 | ||
118 | /// Construct a basic_raw_socket on an existing native socket. | |
119 | /** | |
120 | * This constructor creates a raw socket object to hold an existing | |
121 | * native socket. | |
122 | * | |
b32b8144 | 123 | * @param io_context The io_context object that the raw socket will use |
7c673cae FG |
124 | * to dispatch handlers for any asynchronous operations performed on the |
125 | * socket. | |
126 | * | |
127 | * @param protocol An object specifying protocol parameters to be used. | |
128 | * | |
129 | * @param native_socket The new underlying socket implementation. | |
130 | * | |
131 | * @throws boost::system::system_error Thrown on failure. | |
132 | */ | |
b32b8144 | 133 | basic_raw_socket(boost::asio::io_context& io_context, |
7c673cae | 134 | const protocol_type& protocol, const native_handle_type& native_socket) |
b32b8144 FG |
135 | : basic_socket<Protocol BOOST_ASIO_SVC_TARG>( |
136 | io_context, protocol, native_socket) | |
7c673cae FG |
137 | { |
138 | } | |
139 | ||
140 | #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
141 | /// Move-construct a basic_raw_socket from another. | |
142 | /** | |
143 | * This constructor moves a raw socket from one object to another. | |
144 | * | |
145 | * @param other The other basic_raw_socket object from which the move | |
146 | * will occur. | |
147 | * | |
148 | * @note Following the move, the moved-from object is in the same state as if | |
b32b8144 | 149 | * constructed using the @c basic_raw_socket(io_context&) constructor. |
7c673cae FG |
150 | */ |
151 | basic_raw_socket(basic_raw_socket&& other) | |
b32b8144 | 152 | : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(std::move(other)) |
7c673cae FG |
153 | { |
154 | } | |
155 | ||
156 | /// Move-assign a basic_raw_socket from another. | |
157 | /** | |
158 | * This assignment operator moves a raw socket from one object to another. | |
159 | * | |
160 | * @param other The other basic_raw_socket object from which the move | |
161 | * will occur. | |
162 | * | |
163 | * @note Following the move, the moved-from object is in the same state as if | |
b32b8144 | 164 | * constructed using the @c basic_raw_socket(io_context&) constructor. |
7c673cae FG |
165 | */ |
166 | basic_raw_socket& operator=(basic_raw_socket&& other) | |
167 | { | |
b32b8144 | 168 | basic_socket<Protocol BOOST_ASIO_SVC_TARG>::operator=(std::move(other)); |
7c673cae FG |
169 | return *this; |
170 | } | |
171 | ||
172 | /// Move-construct a basic_raw_socket from a socket of another protocol type. | |
173 | /** | |
174 | * This constructor moves a raw socket from one object to another. | |
175 | * | |
176 | * @param other The other basic_raw_socket object from which the move will | |
177 | * occur. | |
178 | * | |
179 | * @note Following the move, the moved-from object is in the same state as if | |
b32b8144 | 180 | * constructed using the @c basic_raw_socket(io_context&) constructor. |
7c673cae | 181 | */ |
b32b8144 FG |
182 | template <typename Protocol1 BOOST_ASIO_SVC_TPARAM1> |
183 | basic_raw_socket(basic_raw_socket<Protocol1 BOOST_ASIO_SVC_TARG1>&& other, | |
7c673cae | 184 | typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0) |
b32b8144 | 185 | : basic_socket<Protocol BOOST_ASIO_SVC_TARG>(std::move(other)) |
7c673cae FG |
186 | { |
187 | } | |
188 | ||
189 | /// Move-assign a basic_raw_socket from a socket of another protocol type. | |
190 | /** | |
191 | * This assignment operator moves a raw socket from one object to another. | |
192 | * | |
193 | * @param other The other basic_raw_socket object from which the move | |
194 | * will occur. | |
195 | * | |
196 | * @note Following the move, the moved-from object is in the same state as if | |
b32b8144 | 197 | * constructed using the @c basic_raw_socket(io_context&) constructor. |
7c673cae | 198 | */ |
b32b8144 | 199 | template <typename Protocol1 BOOST_ASIO_SVC_TPARAM1> |
7c673cae FG |
200 | typename enable_if<is_convertible<Protocol1, Protocol>::value, |
201 | basic_raw_socket>::type& operator=( | |
b32b8144 | 202 | basic_raw_socket<Protocol1 BOOST_ASIO_SVC_TARG1>&& other) |
7c673cae | 203 | { |
b32b8144 | 204 | basic_socket<Protocol BOOST_ASIO_SVC_TARG>::operator=(std::move(other)); |
7c673cae FG |
205 | return *this; |
206 | } | |
207 | #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) | |
208 | ||
b32b8144 FG |
209 | /// Destroys the socket. |
210 | /** | |
211 | * This function destroys the socket, cancelling any outstanding asynchronous | |
212 | * operations associated with the socket as if by calling @c cancel. | |
213 | */ | |
214 | ~basic_raw_socket() | |
215 | { | |
216 | } | |
217 | ||
7c673cae FG |
218 | /// Send some data on a connected socket. |
219 | /** | |
220 | * This function is used to send data on the raw socket. The function call | |
221 | * will block until the data has been sent successfully or an error occurs. | |
222 | * | |
223 | * @param buffers One ore more data buffers to be sent on the socket. | |
224 | * | |
225 | * @returns The number of bytes sent. | |
226 | * | |
227 | * @throws boost::system::system_error Thrown on failure. | |
228 | * | |
229 | * @note The send operation can only be used with a connected socket. Use | |
230 | * the send_to function to send data on an unconnected raw socket. | |
231 | * | |
232 | * @par Example | |
233 | * To send a single data buffer use the @ref buffer function as follows: | |
234 | * @code socket.send(boost::asio::buffer(data, size)); @endcode | |
235 | * See the @ref buffer documentation for information on sending multiple | |
236 | * buffers in one go, and how to use it with arrays, boost::array or | |
237 | * std::vector. | |
238 | */ | |
239 | template <typename ConstBufferSequence> | |
240 | std::size_t send(const ConstBufferSequence& buffers) | |
241 | { | |
242 | boost::system::error_code ec; | |
243 | std::size_t s = this->get_service().send( | |
244 | this->get_implementation(), buffers, 0, ec); | |
245 | boost::asio::detail::throw_error(ec, "send"); | |
246 | return s; | |
247 | } | |
248 | ||
249 | /// Send some data on a connected socket. | |
250 | /** | |
251 | * This function is used to send data on the raw socket. The function call | |
252 | * will block until the data has been sent successfully or an error occurs. | |
253 | * | |
254 | * @param buffers One ore more data buffers to be sent on the socket. | |
255 | * | |
256 | * @param flags Flags specifying how the send call is to be made. | |
257 | * | |
258 | * @returns The number of bytes sent. | |
259 | * | |
260 | * @throws boost::system::system_error Thrown on failure. | |
261 | * | |
262 | * @note The send operation can only be used with a connected socket. Use | |
263 | * the send_to function to send data on an unconnected raw socket. | |
264 | */ | |
265 | template <typename ConstBufferSequence> | |
266 | std::size_t send(const ConstBufferSequence& buffers, | |
267 | socket_base::message_flags flags) | |
268 | { | |
269 | boost::system::error_code ec; | |
270 | std::size_t s = this->get_service().send( | |
271 | this->get_implementation(), buffers, flags, ec); | |
272 | boost::asio::detail::throw_error(ec, "send"); | |
273 | return s; | |
274 | } | |
275 | ||
276 | /// Send some data on a connected socket. | |
277 | /** | |
278 | * This function is used to send data on the raw socket. The function call | |
279 | * will block until the data has been sent successfully or an error occurs. | |
280 | * | |
281 | * @param buffers One or more data buffers to be sent on the socket. | |
282 | * | |
283 | * @param flags Flags specifying how the send call is to be made. | |
284 | * | |
285 | * @param ec Set to indicate what error occurred, if any. | |
286 | * | |
287 | * @returns The number of bytes sent. | |
288 | * | |
289 | * @note The send operation can only be used with a connected socket. Use | |
290 | * the send_to function to send data on an unconnected raw socket. | |
291 | */ | |
292 | template <typename ConstBufferSequence> | |
293 | std::size_t send(const ConstBufferSequence& buffers, | |
294 | socket_base::message_flags flags, boost::system::error_code& ec) | |
295 | { | |
296 | return this->get_service().send( | |
297 | this->get_implementation(), buffers, flags, ec); | |
298 | } | |
299 | ||
300 | /// Start an asynchronous send on a connected socket. | |
301 | /** | |
302 | * This function is used to send data on the raw socket. The function call | |
303 | * will block until the data has been sent successfully or an error occurs. | |
304 | * | |
305 | * @param buffers One or more data buffers to be sent on the socket. Although | |
306 | * the buffers object may be copied as necessary, ownership of the underlying | |
307 | * memory blocks is retained by the caller, which must guarantee that they | |
308 | * remain valid until the handler is called. | |
309 | * | |
310 | * @param handler The handler to be called when the send operation completes. | |
311 | * Copies will be made of the handler as required. The function signature of | |
312 | * the handler must be: | |
313 | * @code void handler( | |
314 | * const boost::system::error_code& error, // Result of operation. | |
315 | * std::size_t bytes_transferred // Number of bytes sent. | |
316 | * ); @endcode | |
317 | * Regardless of whether the asynchronous operation completes immediately or | |
318 | * not, the handler will not be invoked from within this function. Invocation | |
319 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 320 | * boost::asio::io_context::post(). |
7c673cae FG |
321 | * |
322 | * @note The async_send operation can only be used with a connected socket. | |
323 | * Use the async_send_to function to send data on an unconnected raw | |
324 | * socket. | |
325 | * | |
326 | * @par Example | |
327 | * To send a single data buffer use the @ref buffer function as follows: | |
328 | * @code | |
329 | * socket.async_send(boost::asio::buffer(data, size), handler); | |
330 | * @endcode | |
331 | * See the @ref buffer documentation for information on sending multiple | |
332 | * buffers in one go, and how to use it with arrays, boost::array or | |
333 | * std::vector. | |
334 | */ | |
335 | template <typename ConstBufferSequence, typename WriteHandler> | |
336 | BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, | |
337 | void (boost::system::error_code, std::size_t)) | |
338 | async_send(const ConstBufferSequence& buffers, | |
339 | BOOST_ASIO_MOVE_ARG(WriteHandler) handler) | |
340 | { | |
341 | // If you get an error on the following line it means that your handler does | |
342 | // not meet the documented type requirements for a WriteHandler. | |
343 | BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; | |
344 | ||
b32b8144 | 345 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
346 | return this->get_service().async_send(this->get_implementation(), |
347 | buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); | |
b32b8144 FG |
348 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
349 | async_completion<WriteHandler, | |
350 | void (boost::system::error_code, std::size_t)> init(handler); | |
351 | ||
352 | this->get_service().async_send(this->get_implementation(), | |
353 | buffers, 0, init.completion_handler); | |
354 | ||
355 | return init.result.get(); | |
356 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
357 | } |
358 | ||
359 | /// Start an asynchronous send on a connected socket. | |
360 | /** | |
361 | * This function is used to send data on the raw socket. The function call | |
362 | * will block until the data has been sent successfully or an error occurs. | |
363 | * | |
364 | * @param buffers One or more data buffers to be sent on the socket. Although | |
365 | * the buffers object may be copied as necessary, ownership of the underlying | |
366 | * memory blocks is retained by the caller, which must guarantee that they | |
367 | * remain valid until the handler is called. | |
368 | * | |
369 | * @param flags Flags specifying how the send call is to be made. | |
370 | * | |
371 | * @param handler The handler to be called when the send operation completes. | |
372 | * Copies will be made of the handler as required. The function signature of | |
373 | * the handler must be: | |
374 | * @code void handler( | |
375 | * const boost::system::error_code& error, // Result of operation. | |
376 | * std::size_t bytes_transferred // Number of bytes sent. | |
377 | * ); @endcode | |
378 | * Regardless of whether the asynchronous operation completes immediately or | |
379 | * not, the handler will not be invoked from within this function. Invocation | |
380 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 381 | * boost::asio::io_context::post(). |
7c673cae FG |
382 | * |
383 | * @note The async_send operation can only be used with a connected socket. | |
384 | * Use the async_send_to function to send data on an unconnected raw | |
385 | * socket. | |
386 | */ | |
387 | template <typename ConstBufferSequence, typename WriteHandler> | |
388 | BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, | |
389 | void (boost::system::error_code, std::size_t)) | |
390 | async_send(const ConstBufferSequence& buffers, | |
391 | socket_base::message_flags flags, | |
392 | BOOST_ASIO_MOVE_ARG(WriteHandler) handler) | |
393 | { | |
394 | // If you get an error on the following line it means that your handler does | |
395 | // not meet the documented type requirements for a WriteHandler. | |
396 | BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; | |
397 | ||
b32b8144 | 398 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
399 | return this->get_service().async_send(this->get_implementation(), |
400 | buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); | |
b32b8144 FG |
401 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
402 | async_completion<WriteHandler, | |
403 | void (boost::system::error_code, std::size_t)> init(handler); | |
404 | ||
405 | this->get_service().async_send(this->get_implementation(), | |
406 | buffers, flags, init.completion_handler); | |
407 | ||
408 | return init.result.get(); | |
409 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
410 | } |
411 | ||
412 | /// Send raw data to the specified endpoint. | |
413 | /** | |
414 | * This function is used to send raw data to the specified remote endpoint. | |
415 | * The function call will block until the data has been sent successfully or | |
416 | * an error occurs. | |
417 | * | |
418 | * @param buffers One or more data buffers to be sent to the remote endpoint. | |
419 | * | |
420 | * @param destination The remote endpoint to which the data will be sent. | |
421 | * | |
422 | * @returns The number of bytes sent. | |
423 | * | |
424 | * @throws boost::system::system_error Thrown on failure. | |
425 | * | |
426 | * @par Example | |
427 | * To send a single data buffer use the @ref buffer function as follows: | |
428 | * @code | |
429 | * boost::asio::ip::udp::endpoint destination( | |
430 | * boost::asio::ip::address::from_string("1.2.3.4"), 12345); | |
431 | * socket.send_to(boost::asio::buffer(data, size), destination); | |
432 | * @endcode | |
433 | * See the @ref buffer documentation for information on sending multiple | |
434 | * buffers in one go, and how to use it with arrays, boost::array or | |
435 | * std::vector. | |
436 | */ | |
437 | template <typename ConstBufferSequence> | |
438 | std::size_t send_to(const ConstBufferSequence& buffers, | |
439 | const endpoint_type& destination) | |
440 | { | |
441 | boost::system::error_code ec; | |
442 | std::size_t s = this->get_service().send_to( | |
443 | this->get_implementation(), buffers, destination, 0, ec); | |
444 | boost::asio::detail::throw_error(ec, "send_to"); | |
445 | return s; | |
446 | } | |
447 | ||
448 | /// Send raw data to the specified endpoint. | |
449 | /** | |
450 | * This function is used to send raw data to the specified remote endpoint. | |
451 | * The function call will block until the data has been sent successfully or | |
452 | * an error occurs. | |
453 | * | |
454 | * @param buffers One or more data buffers to be sent to the remote endpoint. | |
455 | * | |
456 | * @param destination The remote endpoint to which the data will be sent. | |
457 | * | |
458 | * @param flags Flags specifying how the send call is to be made. | |
459 | * | |
460 | * @returns The number of bytes sent. | |
461 | * | |
462 | * @throws boost::system::system_error Thrown on failure. | |
463 | */ | |
464 | template <typename ConstBufferSequence> | |
465 | std::size_t send_to(const ConstBufferSequence& buffers, | |
466 | const endpoint_type& destination, socket_base::message_flags flags) | |
467 | { | |
468 | boost::system::error_code ec; | |
469 | std::size_t s = this->get_service().send_to( | |
470 | this->get_implementation(), buffers, destination, flags, ec); | |
471 | boost::asio::detail::throw_error(ec, "send_to"); | |
472 | return s; | |
473 | } | |
474 | ||
475 | /// Send raw data to the specified endpoint. | |
476 | /** | |
477 | * This function is used to send raw data to the specified remote endpoint. | |
478 | * The function call will block until the data has been sent successfully or | |
479 | * an error occurs. | |
480 | * | |
481 | * @param buffers One or more data buffers to be sent to the remote endpoint. | |
482 | * | |
483 | * @param destination The remote endpoint to which the data will be sent. | |
484 | * | |
485 | * @param flags Flags specifying how the send call is to be made. | |
486 | * | |
487 | * @param ec Set to indicate what error occurred, if any. | |
488 | * | |
489 | * @returns The number of bytes sent. | |
490 | */ | |
491 | template <typename ConstBufferSequence> | |
492 | std::size_t send_to(const ConstBufferSequence& buffers, | |
493 | const endpoint_type& destination, socket_base::message_flags flags, | |
494 | boost::system::error_code& ec) | |
495 | { | |
496 | return this->get_service().send_to(this->get_implementation(), | |
497 | buffers, destination, flags, ec); | |
498 | } | |
499 | ||
500 | /// Start an asynchronous send. | |
501 | /** | |
502 | * This function is used to asynchronously send raw data to the specified | |
503 | * remote endpoint. The function call always returns immediately. | |
504 | * | |
505 | * @param buffers One or more data buffers to be sent to the remote endpoint. | |
506 | * Although the buffers object may be copied as necessary, ownership of the | |
507 | * underlying memory blocks is retained by the caller, which must guarantee | |
508 | * that they remain valid until the handler is called. | |
509 | * | |
510 | * @param destination The remote endpoint to which the data will be sent. | |
511 | * Copies will be made of the endpoint as required. | |
512 | * | |
513 | * @param handler The handler to be called when the send operation completes. | |
514 | * Copies will be made of the handler as required. The function signature of | |
515 | * the handler must be: | |
516 | * @code void handler( | |
517 | * const boost::system::error_code& error, // Result of operation. | |
518 | * std::size_t bytes_transferred // Number of bytes sent. | |
519 | * ); @endcode | |
520 | * Regardless of whether the asynchronous operation completes immediately or | |
521 | * not, the handler will not be invoked from within this function. Invocation | |
522 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 523 | * boost::asio::io_context::post(). |
7c673cae FG |
524 | * |
525 | * @par Example | |
526 | * To send a single data buffer use the @ref buffer function as follows: | |
527 | * @code | |
528 | * boost::asio::ip::udp::endpoint destination( | |
529 | * boost::asio::ip::address::from_string("1.2.3.4"), 12345); | |
530 | * socket.async_send_to( | |
531 | * boost::asio::buffer(data, size), destination, handler); | |
532 | * @endcode | |
533 | * See the @ref buffer documentation for information on sending multiple | |
534 | * buffers in one go, and how to use it with arrays, boost::array or | |
535 | * std::vector. | |
536 | */ | |
537 | template <typename ConstBufferSequence, typename WriteHandler> | |
538 | BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, | |
539 | void (boost::system::error_code, std::size_t)) | |
540 | async_send_to(const ConstBufferSequence& buffers, | |
541 | const endpoint_type& destination, | |
542 | BOOST_ASIO_MOVE_ARG(WriteHandler) handler) | |
543 | { | |
544 | // If you get an error on the following line it means that your handler does | |
545 | // not meet the documented type requirements for a WriteHandler. | |
546 | BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; | |
547 | ||
b32b8144 | 548 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
549 | return this->get_service().async_send_to(this->get_implementation(), |
550 | buffers, destination, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); | |
b32b8144 FG |
551 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
552 | async_completion<WriteHandler, | |
553 | void (boost::system::error_code, std::size_t)> init(handler); | |
554 | ||
555 | this->get_service().async_send_to(this->get_implementation(), | |
556 | buffers, destination, 0, init.completion_handler); | |
557 | ||
558 | return init.result.get(); | |
559 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
560 | } |
561 | ||
562 | /// Start an asynchronous send. | |
563 | /** | |
564 | * This function is used to asynchronously send raw data to the specified | |
565 | * remote endpoint. The function call always returns immediately. | |
566 | * | |
567 | * @param buffers One or more data buffers to be sent to the remote endpoint. | |
568 | * Although the buffers object may be copied as necessary, ownership of the | |
569 | * underlying memory blocks is retained by the caller, which must guarantee | |
570 | * that they remain valid until the handler is called. | |
571 | * | |
572 | * @param flags Flags specifying how the send call is to be made. | |
573 | * | |
574 | * @param destination The remote endpoint to which the data will be sent. | |
575 | * Copies will be made of the endpoint as required. | |
576 | * | |
577 | * @param handler The handler to be called when the send operation completes. | |
578 | * Copies will be made of the handler as required. The function signature of | |
579 | * the handler must be: | |
580 | * @code void handler( | |
581 | * const boost::system::error_code& error, // Result of operation. | |
582 | * std::size_t bytes_transferred // Number of bytes sent. | |
583 | * ); @endcode | |
584 | * Regardless of whether the asynchronous operation completes immediately or | |
585 | * not, the handler will not be invoked from within this function. Invocation | |
586 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 587 | * boost::asio::io_context::post(). |
7c673cae FG |
588 | */ |
589 | template <typename ConstBufferSequence, typename WriteHandler> | |
590 | BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, | |
591 | void (boost::system::error_code, std::size_t)) | |
592 | async_send_to(const ConstBufferSequence& buffers, | |
593 | const endpoint_type& destination, socket_base::message_flags flags, | |
594 | BOOST_ASIO_MOVE_ARG(WriteHandler) handler) | |
595 | { | |
596 | // If you get an error on the following line it means that your handler does | |
597 | // not meet the documented type requirements for a WriteHandler. | |
598 | BOOST_ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check; | |
599 | ||
b32b8144 | 600 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
601 | return this->get_service().async_send_to( |
602 | this->get_implementation(), buffers, destination, flags, | |
603 | BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); | |
b32b8144 FG |
604 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
605 | async_completion<WriteHandler, | |
606 | void (boost::system::error_code, std::size_t)> init(handler); | |
607 | ||
608 | this->get_service().async_send_to( | |
609 | this->get_implementation(), buffers, destination, flags, | |
610 | init.completion_handler); | |
611 | ||
612 | return init.result.get(); | |
613 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
614 | } |
615 | ||
616 | /// Receive some data on a connected socket. | |
617 | /** | |
618 | * This function is used to receive data on the raw socket. The function | |
619 | * call will block until data has been received successfully or an error | |
620 | * occurs. | |
621 | * | |
622 | * @param buffers One or more buffers into which the data will be received. | |
623 | * | |
624 | * @returns The number of bytes received. | |
625 | * | |
626 | * @throws boost::system::system_error Thrown on failure. | |
627 | * | |
628 | * @note The receive operation can only be used with a connected socket. Use | |
629 | * the receive_from function to receive data on an unconnected raw | |
630 | * socket. | |
631 | * | |
632 | * @par Example | |
633 | * To receive into a single data buffer use the @ref buffer function as | |
634 | * follows: | |
635 | * @code socket.receive(boost::asio::buffer(data, size)); @endcode | |
636 | * See the @ref buffer documentation for information on receiving into | |
637 | * multiple buffers in one go, and how to use it with arrays, boost::array or | |
638 | * std::vector. | |
639 | */ | |
640 | template <typename MutableBufferSequence> | |
641 | std::size_t receive(const MutableBufferSequence& buffers) | |
642 | { | |
643 | boost::system::error_code ec; | |
644 | std::size_t s = this->get_service().receive( | |
645 | this->get_implementation(), buffers, 0, ec); | |
646 | boost::asio::detail::throw_error(ec, "receive"); | |
647 | return s; | |
648 | } | |
649 | ||
650 | /// Receive some data on a connected socket. | |
651 | /** | |
652 | * This function is used to receive data on the raw socket. The function | |
653 | * call will block until data has been received successfully or an error | |
654 | * occurs. | |
655 | * | |
656 | * @param buffers One or more buffers into which the data will be received. | |
657 | * | |
658 | * @param flags Flags specifying how the receive call is to be made. | |
659 | * | |
660 | * @returns The number of bytes received. | |
661 | * | |
662 | * @throws boost::system::system_error Thrown on failure. | |
663 | * | |
664 | * @note The receive operation can only be used with a connected socket. Use | |
665 | * the receive_from function to receive data on an unconnected raw | |
666 | * socket. | |
667 | */ | |
668 | template <typename MutableBufferSequence> | |
669 | std::size_t receive(const MutableBufferSequence& buffers, | |
670 | socket_base::message_flags flags) | |
671 | { | |
672 | boost::system::error_code ec; | |
673 | std::size_t s = this->get_service().receive( | |
674 | this->get_implementation(), buffers, flags, ec); | |
675 | boost::asio::detail::throw_error(ec, "receive"); | |
676 | return s; | |
677 | } | |
678 | ||
679 | /// Receive some data on a connected socket. | |
680 | /** | |
681 | * This function is used to receive data on the raw socket. The function | |
682 | * call will block until data has been received successfully or an error | |
683 | * occurs. | |
684 | * | |
685 | * @param buffers One or more buffers into which the data will be received. | |
686 | * | |
687 | * @param flags Flags specifying how the receive call is to be made. | |
688 | * | |
689 | * @param ec Set to indicate what error occurred, if any. | |
690 | * | |
691 | * @returns The number of bytes received. | |
692 | * | |
693 | * @note The receive operation can only be used with a connected socket. Use | |
694 | * the receive_from function to receive data on an unconnected raw | |
695 | * socket. | |
696 | */ | |
697 | template <typename MutableBufferSequence> | |
698 | std::size_t receive(const MutableBufferSequence& buffers, | |
699 | socket_base::message_flags flags, boost::system::error_code& ec) | |
700 | { | |
701 | return this->get_service().receive( | |
702 | this->get_implementation(), buffers, flags, ec); | |
703 | } | |
704 | ||
705 | /// Start an asynchronous receive on a connected socket. | |
706 | /** | |
707 | * This function is used to asynchronously receive data from the raw | |
708 | * socket. The function call always returns immediately. | |
709 | * | |
710 | * @param buffers One or more buffers into which the data will be received. | |
711 | * Although the buffers object may be copied as necessary, ownership of the | |
712 | * underlying memory blocks is retained by the caller, which must guarantee | |
713 | * that they remain valid until the handler is called. | |
714 | * | |
715 | * @param handler The handler to be called when the receive operation | |
716 | * completes. Copies will be made of the handler as required. The function | |
717 | * signature of the handler must be: | |
718 | * @code void handler( | |
719 | * const boost::system::error_code& error, // Result of operation. | |
720 | * std::size_t bytes_transferred // Number of bytes received. | |
721 | * ); @endcode | |
722 | * Regardless of whether the asynchronous operation completes immediately or | |
723 | * not, the handler will not be invoked from within this function. Invocation | |
724 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 725 | * boost::asio::io_context::post(). |
7c673cae FG |
726 | * |
727 | * @note The async_receive operation can only be used with a connected socket. | |
728 | * Use the async_receive_from function to receive data on an unconnected | |
729 | * raw socket. | |
730 | * | |
731 | * @par Example | |
732 | * To receive into a single data buffer use the @ref buffer function as | |
733 | * follows: | |
734 | * @code | |
735 | * socket.async_receive(boost::asio::buffer(data, size), handler); | |
736 | * @endcode | |
737 | * See the @ref buffer documentation for information on receiving into | |
738 | * multiple buffers in one go, and how to use it with arrays, boost::array or | |
739 | * std::vector. | |
740 | */ | |
741 | template <typename MutableBufferSequence, typename ReadHandler> | |
742 | BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, | |
743 | void (boost::system::error_code, std::size_t)) | |
744 | async_receive(const MutableBufferSequence& buffers, | |
745 | BOOST_ASIO_MOVE_ARG(ReadHandler) handler) | |
746 | { | |
747 | // If you get an error on the following line it means that your handler does | |
748 | // not meet the documented type requirements for a ReadHandler. | |
749 | BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; | |
750 | ||
b32b8144 | 751 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
752 | return this->get_service().async_receive(this->get_implementation(), |
753 | buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); | |
b32b8144 FG |
754 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
755 | async_completion<ReadHandler, | |
756 | void (boost::system::error_code, std::size_t)> init(handler); | |
757 | ||
758 | this->get_service().async_receive(this->get_implementation(), | |
759 | buffers, 0, init.completion_handler); | |
760 | ||
761 | return init.result.get(); | |
762 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
763 | } |
764 | ||
765 | /// Start an asynchronous receive on a connected socket. | |
766 | /** | |
767 | * This function is used to asynchronously receive data from the raw | |
768 | * socket. The function call always returns immediately. | |
769 | * | |
770 | * @param buffers One or more buffers into which the data will be received. | |
771 | * Although the buffers object may be copied as necessary, ownership of the | |
772 | * underlying memory blocks is retained by the caller, which must guarantee | |
773 | * that they remain valid until the handler is called. | |
774 | * | |
775 | * @param flags Flags specifying how the receive call is to be made. | |
776 | * | |
777 | * @param handler The handler to be called when the receive operation | |
778 | * completes. Copies will be made of the handler as required. The function | |
779 | * signature of the handler must be: | |
780 | * @code void handler( | |
781 | * const boost::system::error_code& error, // Result of operation. | |
782 | * std::size_t bytes_transferred // Number of bytes received. | |
783 | * ); @endcode | |
784 | * Regardless of whether the asynchronous operation completes immediately or | |
785 | * not, the handler will not be invoked from within this function. Invocation | |
786 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 787 | * boost::asio::io_context::post(). |
7c673cae FG |
788 | * |
789 | * @note The async_receive operation can only be used with a connected socket. | |
790 | * Use the async_receive_from function to receive data on an unconnected | |
791 | * raw socket. | |
792 | */ | |
793 | template <typename MutableBufferSequence, typename ReadHandler> | |
794 | BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, | |
795 | void (boost::system::error_code, std::size_t)) | |
796 | async_receive(const MutableBufferSequence& buffers, | |
797 | socket_base::message_flags flags, | |
798 | BOOST_ASIO_MOVE_ARG(ReadHandler) handler) | |
799 | { | |
800 | // If you get an error on the following line it means that your handler does | |
801 | // not meet the documented type requirements for a ReadHandler. | |
802 | BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; | |
803 | ||
b32b8144 | 804 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
805 | return this->get_service().async_receive(this->get_implementation(), |
806 | buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); | |
b32b8144 FG |
807 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
808 | async_completion<ReadHandler, | |
809 | void (boost::system::error_code, std::size_t)> init(handler); | |
810 | ||
811 | this->get_service().async_receive(this->get_implementation(), | |
812 | buffers, flags, init.completion_handler); | |
813 | ||
814 | return init.result.get(); | |
815 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
816 | } |
817 | ||
818 | /// Receive raw data with the endpoint of the sender. | |
819 | /** | |
820 | * This function is used to receive raw data. The function call will block | |
821 | * until data has been received successfully or an error occurs. | |
822 | * | |
823 | * @param buffers One or more buffers into which the data will be received. | |
824 | * | |
825 | * @param sender_endpoint An endpoint object that receives the endpoint of | |
826 | * the remote sender of the data. | |
827 | * | |
828 | * @returns The number of bytes received. | |
829 | * | |
830 | * @throws boost::system::system_error Thrown on failure. | |
831 | * | |
832 | * @par Example | |
833 | * To receive into a single data buffer use the @ref buffer function as | |
834 | * follows: | |
835 | * @code | |
836 | * boost::asio::ip::udp::endpoint sender_endpoint; | |
837 | * socket.receive_from( | |
838 | * boost::asio::buffer(data, size), sender_endpoint); | |
839 | * @endcode | |
840 | * See the @ref buffer documentation for information on receiving into | |
841 | * multiple buffers in one go, and how to use it with arrays, boost::array or | |
842 | * std::vector. | |
843 | */ | |
844 | template <typename MutableBufferSequence> | |
845 | std::size_t receive_from(const MutableBufferSequence& buffers, | |
846 | endpoint_type& sender_endpoint) | |
847 | { | |
848 | boost::system::error_code ec; | |
849 | std::size_t s = this->get_service().receive_from( | |
850 | this->get_implementation(), buffers, sender_endpoint, 0, ec); | |
851 | boost::asio::detail::throw_error(ec, "receive_from"); | |
852 | return s; | |
853 | } | |
854 | ||
855 | /// Receive raw data with the endpoint of the sender. | |
856 | /** | |
857 | * This function is used to receive raw data. The function call will block | |
858 | * until data has been received successfully or an error occurs. | |
859 | * | |
860 | * @param buffers One or more buffers into which the data will be received. | |
861 | * | |
862 | * @param sender_endpoint An endpoint object that receives the endpoint of | |
863 | * the remote sender of the data. | |
864 | * | |
865 | * @param flags Flags specifying how the receive call is to be made. | |
866 | * | |
867 | * @returns The number of bytes received. | |
868 | * | |
869 | * @throws boost::system::system_error Thrown on failure. | |
870 | */ | |
871 | template <typename MutableBufferSequence> | |
872 | std::size_t receive_from(const MutableBufferSequence& buffers, | |
873 | endpoint_type& sender_endpoint, socket_base::message_flags flags) | |
874 | { | |
875 | boost::system::error_code ec; | |
876 | std::size_t s = this->get_service().receive_from( | |
877 | this->get_implementation(), buffers, sender_endpoint, flags, ec); | |
878 | boost::asio::detail::throw_error(ec, "receive_from"); | |
879 | return s; | |
880 | } | |
881 | ||
882 | /// Receive raw data with the endpoint of the sender. | |
883 | /** | |
884 | * This function is used to receive raw data. The function call will block | |
885 | * until data has been received successfully or an error occurs. | |
886 | * | |
887 | * @param buffers One or more buffers into which the data will be received. | |
888 | * | |
889 | * @param sender_endpoint An endpoint object that receives the endpoint of | |
890 | * the remote sender of the data. | |
891 | * | |
892 | * @param flags Flags specifying how the receive call is to be made. | |
893 | * | |
894 | * @param ec Set to indicate what error occurred, if any. | |
895 | * | |
896 | * @returns The number of bytes received. | |
897 | */ | |
898 | template <typename MutableBufferSequence> | |
899 | std::size_t receive_from(const MutableBufferSequence& buffers, | |
900 | endpoint_type& sender_endpoint, socket_base::message_flags flags, | |
901 | boost::system::error_code& ec) | |
902 | { | |
903 | return this->get_service().receive_from(this->get_implementation(), | |
904 | buffers, sender_endpoint, flags, ec); | |
905 | } | |
906 | ||
907 | /// Start an asynchronous receive. | |
908 | /** | |
909 | * This function is used to asynchronously receive raw data. The function | |
910 | * call always returns immediately. | |
911 | * | |
912 | * @param buffers One or more buffers into which the data will be received. | |
913 | * Although the buffers object may be copied as necessary, ownership of the | |
914 | * underlying memory blocks is retained by the caller, which must guarantee | |
915 | * that they remain valid until the handler is called. | |
916 | * | |
917 | * @param sender_endpoint An endpoint object that receives the endpoint of | |
918 | * the remote sender of the data. Ownership of the sender_endpoint object | |
919 | * is retained by the caller, which must guarantee that it is valid until the | |
920 | * handler is called. | |
921 | * | |
922 | * @param handler The handler to be called when the receive operation | |
923 | * completes. Copies will be made of the handler as required. The function | |
924 | * signature of the handler must be: | |
925 | * @code void handler( | |
926 | * const boost::system::error_code& error, // Result of operation. | |
927 | * std::size_t bytes_transferred // Number of bytes received. | |
928 | * ); @endcode | |
929 | * Regardless of whether the asynchronous operation completes immediately or | |
930 | * not, the handler will not be invoked from within this function. Invocation | |
931 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 932 | * boost::asio::io_context::post(). |
7c673cae FG |
933 | * |
934 | * @par Example | |
935 | * To receive into a single data buffer use the @ref buffer function as | |
936 | * follows: | |
937 | * @code socket.async_receive_from( | |
938 | * boost::asio::buffer(data, size), 0, sender_endpoint, handler); @endcode | |
939 | * See the @ref buffer documentation for information on receiving into | |
940 | * multiple buffers in one go, and how to use it with arrays, boost::array or | |
941 | * std::vector. | |
942 | */ | |
943 | template <typename MutableBufferSequence, typename ReadHandler> | |
944 | BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, | |
945 | void (boost::system::error_code, std::size_t)) | |
946 | async_receive_from(const MutableBufferSequence& buffers, | |
947 | endpoint_type& sender_endpoint, | |
948 | BOOST_ASIO_MOVE_ARG(ReadHandler) handler) | |
949 | { | |
950 | // If you get an error on the following line it means that your handler does | |
951 | // not meet the documented type requirements for a ReadHandler. | |
952 | BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; | |
953 | ||
b32b8144 | 954 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
955 | return this->get_service().async_receive_from( |
956 | this->get_implementation(), buffers, sender_endpoint, 0, | |
957 | BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); | |
b32b8144 FG |
958 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
959 | async_completion<ReadHandler, | |
960 | void (boost::system::error_code, std::size_t)> init(handler); | |
961 | ||
962 | this->get_service().async_receive_from( | |
963 | this->get_implementation(), buffers, sender_endpoint, 0, | |
964 | init.completion_handler); | |
965 | ||
966 | return init.result.get(); | |
967 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
968 | } |
969 | ||
970 | /// Start an asynchronous receive. | |
971 | /** | |
972 | * This function is used to asynchronously receive raw data. The function | |
973 | * call always returns immediately. | |
974 | * | |
975 | * @param buffers One or more buffers into which the data will be received. | |
976 | * Although the buffers object may be copied as necessary, ownership of the | |
977 | * underlying memory blocks is retained by the caller, which must guarantee | |
978 | * that they remain valid until the handler is called. | |
979 | * | |
980 | * @param sender_endpoint An endpoint object that receives the endpoint of | |
981 | * the remote sender of the data. Ownership of the sender_endpoint object | |
982 | * is retained by the caller, which must guarantee that it is valid until the | |
983 | * handler is called. | |
984 | * | |
985 | * @param flags Flags specifying how the receive call is to be made. | |
986 | * | |
987 | * @param handler The handler to be called when the receive operation | |
988 | * completes. Copies will be made of the handler as required. The function | |
989 | * signature of the handler must be: | |
990 | * @code void handler( | |
991 | * const boost::system::error_code& error, // Result of operation. | |
992 | * std::size_t bytes_transferred // Number of bytes received. | |
993 | * ); @endcode | |
994 | * Regardless of whether the asynchronous operation completes immediately or | |
995 | * not, the handler will not be invoked from within this function. Invocation | |
996 | * of the handler will be performed in a manner equivalent to using | |
b32b8144 | 997 | * boost::asio::io_context::post(). |
7c673cae FG |
998 | */ |
999 | template <typename MutableBufferSequence, typename ReadHandler> | |
1000 | BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, | |
1001 | void (boost::system::error_code, std::size_t)) | |
1002 | async_receive_from(const MutableBufferSequence& buffers, | |
1003 | endpoint_type& sender_endpoint, socket_base::message_flags flags, | |
1004 | BOOST_ASIO_MOVE_ARG(ReadHandler) handler) | |
1005 | { | |
1006 | // If you get an error on the following line it means that your handler does | |
1007 | // not meet the documented type requirements for a ReadHandler. | |
1008 | BOOST_ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check; | |
1009 | ||
b32b8144 | 1010 | #if defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
7c673cae FG |
1011 | return this->get_service().async_receive_from( |
1012 | this->get_implementation(), buffers, sender_endpoint, flags, | |
1013 | BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); | |
b32b8144 FG |
1014 | #else // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) |
1015 | async_completion<ReadHandler, | |
1016 | void (boost::system::error_code, std::size_t)> init(handler); | |
1017 | ||
1018 | this->get_service().async_receive_from( | |
1019 | this->get_implementation(), buffers, sender_endpoint, flags, | |
1020 | init.completion_handler); | |
1021 | ||
1022 | return init.result.get(); | |
1023 | #endif // defined(BOOST_ASIO_ENABLE_OLD_SERVICES) | |
7c673cae FG |
1024 | } |
1025 | }; | |
1026 | ||
1027 | } // namespace asio | |
1028 | } // namespace boost | |
1029 | ||
1030 | #include <boost/asio/detail/pop_options.hpp> | |
1031 | ||
1032 | #endif // BOOST_ASIO_BASIC_RAW_SOCKET_HPP |