// | |
// basic_raw_socket.hpp | |
// ~~~~~~~~~~~~~~~~~~~~ | |
// | |
// Copyright (c) 2003-2011 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) | |
// | |
#ifndef BOOST_ASIO_BASIC_RAW_SOCKET_HPP | |
#define BOOST_ASIO_BASIC_RAW_SOCKET_HPP | |
#if defined(_MSC_VER) && (_MSC_VER >= 1200) | |
# pragma once | |
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200) | |
#include <boost/asio/detail/config.hpp> | |
#include <cstddef> | |
#include <boost/asio/basic_socket.hpp> | |
#include <boost/asio/detail/throw_error.hpp> | |
#include <boost/asio/error.hpp> | |
#include <boost/asio/raw_socket_service.hpp> | |
#include <boost/asio/detail/push_options.hpp> | |
namespace boost { | |
namespace asio { | |
/// Provides raw-oriented socket functionality. | |
/** | |
* The basic_raw_socket class template provides asynchronous and blocking | |
* raw-oriented socket functionality. | |
* | |
* @par Thread Safety | |
* @e Distinct @e objects: Safe.@n | |
* @e Shared @e objects: Unsafe. | |
*/ | |
template <typename Protocol, | |
typename RawSocketService = raw_socket_service<Protocol> > | |
class basic_raw_socket | |
: public basic_socket<Protocol, RawSocketService> | |
{ | |
public: | |
/// The native representation of a socket. | |
typedef typename RawSocketService::native_type native_type; | |
/// The protocol type. | |
typedef Protocol protocol_type; | |
/// The endpoint type. | |
typedef typename Protocol::endpoint endpoint_type; | |
/// Construct a basic_raw_socket without opening it. | |
/** | |
* This constructor creates a raw socket without opening it. The open() | |
* function must be called before data can be sent or received on the socket. | |
* | |
* @param io_service The io_service object that the raw socket will use | |
* to dispatch handlers for any asynchronous operations performed on the | |
* socket. | |
*/ | |
explicit basic_raw_socket(boost::asio::io_service& io_service) | |
: basic_socket<Protocol, RawSocketService>(io_service) | |
{ | |
} | |
/// Construct and open a basic_raw_socket. | |
/** | |
* This constructor creates and opens a raw socket. | |
* | |
* @param io_service The io_service object that the raw socket will use | |
* to dispatch handlers for any asynchronous operations performed on the | |
* socket. | |
* | |
* @param protocol An object specifying protocol parameters to be used. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
*/ | |
basic_raw_socket(boost::asio::io_service& io_service, | |
const protocol_type& protocol) | |
: basic_socket<Protocol, RawSocketService>(io_service, protocol) | |
{ | |
} | |
/// Construct a basic_raw_socket, opening it and binding it to the given | |
/// local endpoint. | |
/** | |
* This constructor creates a raw socket and automatically opens it bound | |
* to the specified endpoint on the local machine. The protocol used is the | |
* protocol associated with the given endpoint. | |
* | |
* @param io_service The io_service object that the raw socket will use | |
* to dispatch handlers for any asynchronous operations performed on the | |
* socket. | |
* | |
* @param endpoint An endpoint on the local machine to which the raw | |
* socket will be bound. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
*/ | |
basic_raw_socket(boost::asio::io_service& io_service, | |
const endpoint_type& endpoint) | |
: basic_socket<Protocol, RawSocketService>(io_service, endpoint) | |
{ | |
} | |
/// Construct a basic_raw_socket on an existing native socket. | |
/** | |
* This constructor creates a raw socket object to hold an existing | |
* native socket. | |
* | |
* @param io_service The io_service object that the raw socket will use | |
* to dispatch handlers for any asynchronous operations performed on the | |
* socket. | |
* | |
* @param protocol An object specifying protocol parameters to be used. | |
* | |
* @param native_socket The new underlying socket implementation. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
*/ | |
basic_raw_socket(boost::asio::io_service& io_service, | |
const protocol_type& protocol, const native_type& native_socket) | |
: basic_socket<Protocol, RawSocketService>( | |
io_service, protocol, native_socket) | |
{ | |
} | |
/// Send some data on a connected socket. | |
/** | |
* This function is used to send data on the raw socket. The function call | |
* will block until the data has been sent successfully or an error occurs. | |
* | |
* @param buffers One ore more data buffers to be sent on the socket. | |
* | |
* @returns The number of bytes sent. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
* | |
* @note The send operation can only be used with a connected socket. Use | |
* the send_to function to send data on an unconnected raw socket. | |
* | |
* @par Example | |
* To send a single data buffer use the @ref buffer function as follows: | |
* @code socket.send(boost::asio::buffer(data, size)); @endcode | |
* See the @ref buffer documentation for information on sending multiple | |
* buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename ConstBufferSequence> | |
std::size_t send(const ConstBufferSequence& buffers) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.send(this->implementation, buffers, 0, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Send some data on a connected socket. | |
/** | |
* This function is used to send data on the raw socket. The function call | |
* will block until the data has been sent successfully or an error occurs. | |
* | |
* @param buffers One ore more data buffers to be sent on the socket. | |
* | |
* @param flags Flags specifying how the send call is to be made. | |
* | |
* @returns The number of bytes sent. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
* | |
* @note The send operation can only be used with a connected socket. Use | |
* the send_to function to send data on an unconnected raw socket. | |
*/ | |
template <typename ConstBufferSequence> | |
std::size_t send(const ConstBufferSequence& buffers, | |
socket_base::message_flags flags) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.send( | |
this->implementation, buffers, flags, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Send some data on a connected socket. | |
/** | |
* This function is used to send data on the raw socket. The function call | |
* will block until the data has been sent successfully or an error occurs. | |
* | |
* @param buffers One or more data buffers to be sent on the socket. | |
* | |
* @param flags Flags specifying how the send call is to be made. | |
* | |
* @param ec Set to indicate what error occurred, if any. | |
* | |
* @returns The number of bytes sent. | |
* | |
* @note The send operation can only be used with a connected socket. Use | |
* the send_to function to send data on an unconnected raw socket. | |
*/ | |
template <typename ConstBufferSequence> | |
std::size_t send(const ConstBufferSequence& buffers, | |
socket_base::message_flags flags, boost::system::error_code& ec) | |
{ | |
return this->service.send(this->implementation, buffers, flags, ec); | |
} | |
/// Start an asynchronous send on a connected socket. | |
/** | |
* This function is used to send data on the raw socket. The function call | |
* will block until the data has been sent successfully or an error occurs. | |
* | |
* @param buffers One or more data buffers to be sent on the socket. Although | |
* the buffers object may be copied as necessary, ownership of the underlying | |
* memory blocks is retained by the caller, which must guarantee that they | |
* remain valid until the handler is called. | |
* | |
* @param handler The handler to be called when the send operation completes. | |
* Copies will be made of the handler as required. The function signature of | |
* the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes sent. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
* | |
* @note The async_send operation can only be used with a connected socket. | |
* Use the async_send_to function to send data on an unconnected raw | |
* socket. | |
* | |
* @par Example | |
* To send a single data buffer use the @ref buffer function as follows: | |
* @code | |
* socket.async_send(boost::asio::buffer(data, size), handler); | |
* @endcode | |
* See the @ref buffer documentation for information on sending multiple | |
* buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename ConstBufferSequence, typename WriteHandler> | |
void async_send(const ConstBufferSequence& buffers, WriteHandler handler) | |
{ | |
this->service.async_send(this->implementation, buffers, 0, handler); | |
} | |
/// Start an asynchronous send on a connected socket. | |
/** | |
* This function is used to send data on the raw socket. The function call | |
* will block until the data has been sent successfully or an error occurs. | |
* | |
* @param buffers One or more data buffers to be sent on the socket. Although | |
* the buffers object may be copied as necessary, ownership of the underlying | |
* memory blocks is retained by the caller, which must guarantee that they | |
* remain valid until the handler is called. | |
* | |
* @param flags Flags specifying how the send call is to be made. | |
* | |
* @param handler The handler to be called when the send operation completes. | |
* Copies will be made of the handler as required. The function signature of | |
* the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes sent. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
* | |
* @note The async_send operation can only be used with a connected socket. | |
* Use the async_send_to function to send data on an unconnected raw | |
* socket. | |
*/ | |
template <typename ConstBufferSequence, typename WriteHandler> | |
void async_send(const ConstBufferSequence& buffers, | |
socket_base::message_flags flags, WriteHandler handler) | |
{ | |
this->service.async_send(this->implementation, buffers, flags, handler); | |
} | |
/// Send raw data to the specified endpoint. | |
/** | |
* This function is used to send raw data to the specified remote endpoint. | |
* The function call will block until the data has been sent successfully or | |
* an error occurs. | |
* | |
* @param buffers One or more data buffers to be sent to the remote endpoint. | |
* | |
* @param destination The remote endpoint to which the data will be sent. | |
* | |
* @returns The number of bytes sent. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
* | |
* @par Example | |
* To send a single data buffer use the @ref buffer function as follows: | |
* @code | |
* boost::asio::ip::udp::endpoint destination( | |
* boost::asio::ip::address::from_string("1.2.3.4"), 12345); | |
* socket.send_to(boost::asio::buffer(data, size), destination); | |
* @endcode | |
* See the @ref buffer documentation for information on sending multiple | |
* buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename ConstBufferSequence> | |
std::size_t send_to(const ConstBufferSequence& buffers, | |
const endpoint_type& destination) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.send_to( | |
this->implementation, buffers, destination, 0, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Send raw data to the specified endpoint. | |
/** | |
* This function is used to send raw data to the specified remote endpoint. | |
* The function call will block until the data has been sent successfully or | |
* an error occurs. | |
* | |
* @param buffers One or more data buffers to be sent to the remote endpoint. | |
* | |
* @param destination The remote endpoint to which the data will be sent. | |
* | |
* @param flags Flags specifying how the send call is to be made. | |
* | |
* @returns The number of bytes sent. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
*/ | |
template <typename ConstBufferSequence> | |
std::size_t send_to(const ConstBufferSequence& buffers, | |
const endpoint_type& destination, socket_base::message_flags flags) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.send_to( | |
this->implementation, buffers, destination, flags, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Send raw data to the specified endpoint. | |
/** | |
* This function is used to send raw data to the specified remote endpoint. | |
* The function call will block until the data has been sent successfully or | |
* an error occurs. | |
* | |
* @param buffers One or more data buffers to be sent to the remote endpoint. | |
* | |
* @param destination The remote endpoint to which the data will be sent. | |
* | |
* @param flags Flags specifying how the send call is to be made. | |
* | |
* @param ec Set to indicate what error occurred, if any. | |
* | |
* @returns The number of bytes sent. | |
*/ | |
template <typename ConstBufferSequence> | |
std::size_t send_to(const ConstBufferSequence& buffers, | |
const endpoint_type& destination, socket_base::message_flags flags, | |
boost::system::error_code& ec) | |
{ | |
return this->service.send_to(this->implementation, | |
buffers, destination, flags, ec); | |
} | |
/// Start an asynchronous send. | |
/** | |
* This function is used to asynchronously send raw data to the specified | |
* remote endpoint. The function call always returns immediately. | |
* | |
* @param buffers One or more data buffers to be sent to the remote endpoint. | |
* Although the buffers object may be copied as necessary, ownership of the | |
* underlying memory blocks is retained by the caller, which must guarantee | |
* that they remain valid until the handler is called. | |
* | |
* @param destination The remote endpoint to which the data will be sent. | |
* Copies will be made of the endpoint as required. | |
* | |
* @param handler The handler to be called when the send operation completes. | |
* Copies will be made of the handler as required. The function signature of | |
* the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes sent. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
* | |
* @par Example | |
* To send a single data buffer use the @ref buffer function as follows: | |
* @code | |
* boost::asio::ip::udp::endpoint destination( | |
* boost::asio::ip::address::from_string("1.2.3.4"), 12345); | |
* socket.async_send_to( | |
* boost::asio::buffer(data, size), destination, handler); | |
* @endcode | |
* See the @ref buffer documentation for information on sending multiple | |
* buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename ConstBufferSequence, typename WriteHandler> | |
void async_send_to(const ConstBufferSequence& buffers, | |
const endpoint_type& destination, WriteHandler handler) | |
{ | |
this->service.async_send_to(this->implementation, buffers, destination, 0, | |
handler); | |
} | |
/// Start an asynchronous send. | |
/** | |
* This function is used to asynchronously send raw data to the specified | |
* remote endpoint. The function call always returns immediately. | |
* | |
* @param buffers One or more data buffers to be sent to the remote endpoint. | |
* Although the buffers object may be copied as necessary, ownership of the | |
* underlying memory blocks is retained by the caller, which must guarantee | |
* that they remain valid until the handler is called. | |
* | |
* @param flags Flags specifying how the send call is to be made. | |
* | |
* @param destination The remote endpoint to which the data will be sent. | |
* Copies will be made of the endpoint as required. | |
* | |
* @param handler The handler to be called when the send operation completes. | |
* Copies will be made of the handler as required. The function signature of | |
* the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes sent. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
*/ | |
template <typename ConstBufferSequence, typename WriteHandler> | |
void async_send_to(const ConstBufferSequence& buffers, | |
const endpoint_type& destination, socket_base::message_flags flags, | |
WriteHandler handler) | |
{ | |
this->service.async_send_to(this->implementation, buffers, destination, | |
flags, handler); | |
} | |
/// Receive some data on a connected socket. | |
/** | |
* This function is used to receive data on the raw socket. The function | |
* call will block until data has been received successfully or an error | |
* occurs. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* | |
* @returns The number of bytes received. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
* | |
* @note The receive operation can only be used with a connected socket. Use | |
* the receive_from function to receive data on an unconnected raw | |
* socket. | |
* | |
* @par Example | |
* To receive into a single data buffer use the @ref buffer function as | |
* follows: | |
* @code socket.receive(boost::asio::buffer(data, size)); @endcode | |
* See the @ref buffer documentation for information on receiving into | |
* multiple buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename MutableBufferSequence> | |
std::size_t receive(const MutableBufferSequence& buffers) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.receive( | |
this->implementation, buffers, 0, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Receive some data on a connected socket. | |
/** | |
* This function is used to receive data on the raw socket. The function | |
* call will block until data has been received successfully or an error | |
* occurs. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* | |
* @param flags Flags specifying how the receive call is to be made. | |
* | |
* @returns The number of bytes received. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
* | |
* @note The receive operation can only be used with a connected socket. Use | |
* the receive_from function to receive data on an unconnected raw | |
* socket. | |
*/ | |
template <typename MutableBufferSequence> | |
std::size_t receive(const MutableBufferSequence& buffers, | |
socket_base::message_flags flags) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.receive( | |
this->implementation, buffers, flags, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Receive some data on a connected socket. | |
/** | |
* This function is used to receive data on the raw socket. The function | |
* call will block until data has been received successfully or an error | |
* occurs. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* | |
* @param flags Flags specifying how the receive call is to be made. | |
* | |
* @param ec Set to indicate what error occurred, if any. | |
* | |
* @returns The number of bytes received. | |
* | |
* @note The receive operation can only be used with a connected socket. Use | |
* the receive_from function to receive data on an unconnected raw | |
* socket. | |
*/ | |
template <typename MutableBufferSequence> | |
std::size_t receive(const MutableBufferSequence& buffers, | |
socket_base::message_flags flags, boost::system::error_code& ec) | |
{ | |
return this->service.receive(this->implementation, buffers, flags, ec); | |
} | |
/// Start an asynchronous receive on a connected socket. | |
/** | |
* This function is used to asynchronously receive data from the raw | |
* socket. The function call always returns immediately. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* Although the buffers object may be copied as necessary, ownership of the | |
* underlying memory blocks is retained by the caller, which must guarantee | |
* that they remain valid until the handler is called. | |
* | |
* @param handler The handler to be called when the receive operation | |
* completes. Copies will be made of the handler as required. The function | |
* signature of the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes received. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
* | |
* @note The async_receive operation can only be used with a connected socket. | |
* Use the async_receive_from function to receive data on an unconnected | |
* raw socket. | |
* | |
* @par Example | |
* To receive into a single data buffer use the @ref buffer function as | |
* follows: | |
* @code | |
* socket.async_receive(boost::asio::buffer(data, size), handler); | |
* @endcode | |
* See the @ref buffer documentation for information on receiving into | |
* multiple buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename MutableBufferSequence, typename ReadHandler> | |
void async_receive(const MutableBufferSequence& buffers, ReadHandler handler) | |
{ | |
this->service.async_receive(this->implementation, buffers, 0, handler); | |
} | |
/// Start an asynchronous receive on a connected socket. | |
/** | |
* This function is used to asynchronously receive data from the raw | |
* socket. The function call always returns immediately. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* Although the buffers object may be copied as necessary, ownership of the | |
* underlying memory blocks is retained by the caller, which must guarantee | |
* that they remain valid until the handler is called. | |
* | |
* @param flags Flags specifying how the receive call is to be made. | |
* | |
* @param handler The handler to be called when the receive operation | |
* completes. Copies will be made of the handler as required. The function | |
* signature of the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes received. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
* | |
* @note The async_receive operation can only be used with a connected socket. | |
* Use the async_receive_from function to receive data on an unconnected | |
* raw socket. | |
*/ | |
template <typename MutableBufferSequence, typename ReadHandler> | |
void async_receive(const MutableBufferSequence& buffers, | |
socket_base::message_flags flags, ReadHandler handler) | |
{ | |
this->service.async_receive(this->implementation, buffers, flags, handler); | |
} | |
/// Receive raw data with the endpoint of the sender. | |
/** | |
* This function is used to receive raw data. The function call will block | |
* until data has been received successfully or an error occurs. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* | |
* @param sender_endpoint An endpoint object that receives the endpoint of | |
* the remote sender of the data. | |
* | |
* @returns The number of bytes received. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
* | |
* @par Example | |
* To receive into a single data buffer use the @ref buffer function as | |
* follows: | |
* @code | |
* boost::asio::ip::udp::endpoint sender_endpoint; | |
* socket.receive_from( | |
* boost::asio::buffer(data, size), sender_endpoint); | |
* @endcode | |
* See the @ref buffer documentation for information on receiving into | |
* multiple buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename MutableBufferSequence> | |
std::size_t receive_from(const MutableBufferSequence& buffers, | |
endpoint_type& sender_endpoint) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.receive_from( | |
this->implementation, buffers, sender_endpoint, 0, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Receive raw data with the endpoint of the sender. | |
/** | |
* This function is used to receive raw data. The function call will block | |
* until data has been received successfully or an error occurs. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* | |
* @param sender_endpoint An endpoint object that receives the endpoint of | |
* the remote sender of the data. | |
* | |
* @param flags Flags specifying how the receive call is to be made. | |
* | |
* @returns The number of bytes received. | |
* | |
* @throws boost::system::system_error Thrown on failure. | |
*/ | |
template <typename MutableBufferSequence> | |
std::size_t receive_from(const MutableBufferSequence& buffers, | |
endpoint_type& sender_endpoint, socket_base::message_flags flags) | |
{ | |
boost::system::error_code ec; | |
std::size_t s = this->service.receive_from( | |
this->implementation, buffers, sender_endpoint, flags, ec); | |
boost::asio::detail::throw_error(ec); | |
return s; | |
} | |
/// Receive raw data with the endpoint of the sender. | |
/** | |
* This function is used to receive raw data. The function call will block | |
* until data has been received successfully or an error occurs. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* | |
* @param sender_endpoint An endpoint object that receives the endpoint of | |
* the remote sender of the data. | |
* | |
* @param flags Flags specifying how the receive call is to be made. | |
* | |
* @param ec Set to indicate what error occurred, if any. | |
* | |
* @returns The number of bytes received. | |
*/ | |
template <typename MutableBufferSequence> | |
std::size_t receive_from(const MutableBufferSequence& buffers, | |
endpoint_type& sender_endpoint, socket_base::message_flags flags, | |
boost::system::error_code& ec) | |
{ | |
return this->service.receive_from(this->implementation, buffers, | |
sender_endpoint, flags, ec); | |
} | |
/// Start an asynchronous receive. | |
/** | |
* This function is used to asynchronously receive raw data. The function | |
* call always returns immediately. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* Although the buffers object may be copied as necessary, ownership of the | |
* underlying memory blocks is retained by the caller, which must guarantee | |
* that they remain valid until the handler is called. | |
* | |
* @param sender_endpoint An endpoint object that receives the endpoint of | |
* the remote sender of the data. Ownership of the sender_endpoint object | |
* is retained by the caller, which must guarantee that it is valid until the | |
* handler is called. | |
* | |
* @param handler The handler to be called when the receive operation | |
* completes. Copies will be made of the handler as required. The function | |
* signature of the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes received. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
* | |
* @par Example | |
* To receive into a single data buffer use the @ref buffer function as | |
* follows: | |
* @code socket.async_receive_from( | |
* boost::asio::buffer(data, size), 0, sender_endpoint, handler); @endcode | |
* See the @ref buffer documentation for information on receiving into | |
* multiple buffers in one go, and how to use it with arrays, boost::array or | |
* std::vector. | |
*/ | |
template <typename MutableBufferSequence, typename ReadHandler> | |
void async_receive_from(const MutableBufferSequence& buffers, | |
endpoint_type& sender_endpoint, ReadHandler handler) | |
{ | |
this->service.async_receive_from(this->implementation, buffers, | |
sender_endpoint, 0, handler); | |
} | |
/// Start an asynchronous receive. | |
/** | |
* This function is used to asynchronously receive raw data. The function | |
* call always returns immediately. | |
* | |
* @param buffers One or more buffers into which the data will be received. | |
* Although the buffers object may be copied as necessary, ownership of the | |
* underlying memory blocks is retained by the caller, which must guarantee | |
* that they remain valid until the handler is called. | |
* | |
* @param sender_endpoint An endpoint object that receives the endpoint of | |
* the remote sender of the data. Ownership of the sender_endpoint object | |
* is retained by the caller, which must guarantee that it is valid until the | |
* handler is called. | |
* | |
* @param flags Flags specifying how the receive call is to be made. | |
* | |
* @param handler The handler to be called when the receive operation | |
* completes. Copies will be made of the handler as required. The function | |
* signature of the handler must be: | |
* @code void handler( | |
* const boost::system::error_code& error, // Result of operation. | |
* std::size_t bytes_transferred // Number of bytes received. | |
* ); @endcode | |
* Regardless of whether the asynchronous operation completes immediately or | |
* not, the handler will not be invoked from within this function. Invocation | |
* of the handler will be performed in a manner equivalent to using | |
* boost::asio::io_service::post(). | |
*/ | |
template <typename MutableBufferSequence, typename ReadHandler> | |
void async_receive_from(const MutableBufferSequence& buffers, | |
endpoint_type& sender_endpoint, socket_base::message_flags flags, | |
ReadHandler handler) | |
{ | |
this->service.async_receive_from(this->implementation, buffers, | |
sender_endpoint, flags, handler); | |
} | |
}; | |
} // namespace asio | |
} // namespace boost | |
#include <boost/asio/detail/pop_options.hpp> | |
#endif // BOOST_ASIO_BASIC_RAW_SOCKET_HPP |