//

// basic_socket.hpp

// ~~~~~~~~~~~~~~~~

//

// Copyright (c) 2003-2021 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 ASIO_BASIC_SOCKET_HPP

#define ASIO_BASIC_SOCKET_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)

# pragma once

#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include "asio/any_io_executor.hpp"

#include "asio/detail/config.hpp"

#include "asio/async_result.hpp"

#include "asio/detail/handler_type_requirements.hpp"

#include "asio/detail/io_object_impl.hpp"

#include "asio/detail/non_const_lvalue.hpp"

#include "asio/detail/throw_error.hpp"

#include "asio/detail/type_traits.hpp"

#include "asio/error.hpp"

#include "asio/execution_context.hpp"

#include "asio/post.hpp"

#include "asio/socket_base.hpp"

#if defined(ASIO_WINDOWS_RUNTIME)

# include "asio/detail/null_socket_service.hpp"

#elif defined(ASIO_HAS_IOCP)

# include "asio/detail/win_iocp_socket_service.hpp"

#else

# include "asio/detail/reactive_socket_service.hpp"

#endif

#if defined(ASIO_HAS_MOVE)

# include <utility>

#endif // defined(ASIO_HAS_MOVE)

#include "asio/detail/push_options.hpp"

namespace asio {

#if !defined(ASIO_BASIC_SOCKET_FWD_DECL)

#define ASIO_BASIC_SOCKET_FWD_DECL

// Forward declaration with defaulted arguments.

template <typename Protocol, typename Executor = any_io_executor>

class basic_socket;

#endif // !defined(ASIO_BASIC_SOCKET_FWD_DECL)

/// Provides socket functionality.

/**

* The basic_socket class template provides functionality that is common to both

* stream-oriented and datagram-oriented sockets.

*

* @par Thread Safety

* @e Distinct @e objects: Safe.@n

* @e Shared @e objects: Unsafe.

*/

template <typename Protocol, typename Executor>

class basic_socket

: public socket_base

{

public:

/// The type of the executor associated with the object.

typedef Executor executor_type;

/// Rebinds the socket type to another executor.

template <typename Executor1>

struct rebind_executor

{

/// The socket type when rebound to the specified executor.

typedef basic_socket<Protocol, Executor1> other;

};

/// The native representation of a socket.

#if defined(GENERATING_DOCUMENTATION)

typedef implementation_defined native_handle_type;

#elif defined(ASIO_WINDOWS_RUNTIME)

typedef typename detail::null_socket_service<

Protocol>::native_handle_type native_handle_type;

#elif defined(ASIO_HAS_IOCP)

typedef typename detail::win_iocp_socket_service<

Protocol>::native_handle_type native_handle_type;

#else

typedef typename detail::reactive_socket_service<

Protocol>::native_handle_type native_handle_type;

#endif

/// The protocol type.

typedef Protocol protocol_type;

/// The endpoint type.

typedef typename Protocol::endpoint endpoint_type;

#if !defined(ASIO_NO_EXTENSIONS)

/// A basic_socket is always the lowest layer.

typedef basic_socket<Protocol, Executor> lowest_layer_type;

#endif // !defined(ASIO_NO_EXTENSIONS)

/// Construct a basic_socket without opening it.

/**

* This constructor creates a socket without opening it.

*

* @param ex The I/O executor that the socket will use, by default, to

* dispatch handlers for any asynchronous operations performed on the socket.

*/

explicit basic_socket(const executor_type& ex)

: impl_(0, ex)

{

}

/// Construct a basic_socket without opening it.

/**

* This constructor creates a socket without opening it.

*

* @param context An execution context which provides the I/O executor that

* the socket will use, by default, to dispatch handlers for any asynchronous

* operations performed on the socket.

*/

template <typename ExecutionContext>

explicit basic_socket(ExecutionContext& context,

typename constraint<

is_convertible<ExecutionContext&, execution_context&>::value

>::type = 0)

: impl_(0, 0, context)

{

}

/// Construct and open a basic_socket.

/**

* This constructor creates and opens a socket.

*

* @param ex The I/O executor that the socket will use, by default, to

* dispatch handlers for any asynchronous operations performed on the socket.

*

* @param protocol An object specifying protocol parameters to be used.

*

* @throws asio::system_error Thrown on failure.

*/

basic_socket(const executor_type& ex, const protocol_type& protocol)

: impl_(0, ex)

{

asio::error_code ec;

impl_.get_service().open(impl_.get_implementation(), protocol, ec);

asio::detail::throw_error(ec, "open");

}

/// Construct and open a basic_socket.

/**

* This constructor creates and opens a socket.

*

* @param context An execution context which provides the I/O executor that

* the socket will use, by default, to dispatch handlers for any asynchronous

* operations performed on the socket.

*

* @param protocol An object specifying protocol parameters to be used.

*

* @throws asio::system_error Thrown on failure.

*/

template <typename ExecutionContext>

basic_socket(ExecutionContext& context, const protocol_type& protocol,

typename constraint<

is_convertible<ExecutionContext&, execution_context&>::value,

defaulted_constraint

>::type = defaulted_constraint())

: impl_(0, 0, context)

{

asio::error_code ec;

impl_.get_service().open(impl_.get_implementation(), protocol, ec);

asio::detail::throw_error(ec, "open");

}

/// Construct a basic_socket, opening it and binding it to the given local

/// endpoint.

/**

* This constructor creates a 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 ex The I/O executor that the socket will use, by default, to

* dispatch handlers for any asynchronous operations performed on the socket.

*

* @param endpoint An endpoint on the local machine to which the socket will

* be bound.

*

* @throws asio::system_error Thrown on failure.

*/

basic_socket(const executor_type& ex, const endpoint_type& endpoint)

: impl_(0, ex)

{

asio::error_code ec;

const protocol_type protocol = endpoint.protocol();

impl_.get_service().open(impl_.get_implementation(), protocol, ec);

asio::detail::throw_error(ec, "open");

impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);

asio::detail::throw_error(ec, "bind");

}

/// Construct a basic_socket, opening it and binding it to the given local

/// endpoint.

/**

* This constructor creates a 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 context An execution context which provides the I/O executor that

* the socket will use, by default, to dispatch handlers for any asynchronous

* operations performed on the socket.

*

* @param endpoint An endpoint on the local machine to which the socket will

* be bound.

*

* @throws asio::system_error Thrown on failure.

*/

template <typename ExecutionContext>

basic_socket(ExecutionContext& context, const endpoint_type& endpoint,

typename constraint<

is_convertible<ExecutionContext&, execution_context&>::value

>::type = 0)

: impl_(0, 0, context)

{

asio::error_code ec;

const protocol_type protocol = endpoint.protocol();

impl_.get_service().open(impl_.get_implementation(), protocol, ec);

asio::detail::throw_error(ec, "open");

impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);

asio::detail::throw_error(ec, "bind");

}

/// Construct a basic_socket on an existing native socket.

/**

* This constructor creates a socket object to hold an existing native socket.

*

* @param ex The I/O executor that the socket will use, by default, to

* dispatch handlers for any asynchronous operations performed on the socket.

*

* @param protocol An object specifying protocol parameters to be used.

*

* @param native_socket A native socket.

*

* @throws asio::system_error Thrown on failure.

*/

basic_socket(const executor_type& ex, const protocol_type& protocol,

const native_handle_type& native_socket)

: impl_(0, ex)

{

asio::error_code ec;

impl_.get_service().assign(impl_.get_implementation(),

protocol, native_socket, ec);

asio::detail::throw_error(ec, "assign");

}

/// Construct a basic_socket on an existing native socket.

/**

* This constructor creates a socket object to hold an existing native socket.

*

* @param context An execution context which provides the I/O executor that

* the socket will use, by default, to dispatch handlers for any asynchronous

* operations performed on the socket.

*

* @param protocol An object specifying protocol parameters to be used.

*

* @param native_socket A native socket.

*

* @throws asio::system_error Thrown on failure.

*/

template <typename ExecutionContext>

basic_socket(ExecutionContext& context, const protocol_type& protocol,

const native_handle_type& native_socket,

typename constraint<

is_convertible<ExecutionContext&, execution_context&>::value

>::type = 0)

: impl_(0, 0, context)

{

asio::error_code ec;

impl_.get_service().assign(impl_.get_implementation(),

protocol, native_socket, ec);

asio::detail::throw_error(ec, "assign");

}

#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

/// Move-construct a basic_socket from another.

/**

* This constructor moves a socket from one object to another.

*

* @param other The other basic_socket object from which the move will

* occur.

*

* @note Following the move, the moved-from object is in the same state as if

* constructed using the @c basic_socket(const executor_type&) constructor.

*/

basic_socket(basic_socket&& other) ASIO_NOEXCEPT

: impl_(std::move(other.impl_))

{

}

/// Move-assign a basic_socket from another.

/**

* This assignment operator moves a socket from one object to another.

*

* @param other The other basic_socket object from which the move will

* occur.

*

* @note Following the move, the moved-from object is in the same state as if

* constructed using the @c basic_socket(const executor_type&) constructor.

*/

basic_socket& operator=(basic_socket&& other)

{

impl_ = std::move(other.impl_);

return *this;

}

// All sockets have access to each other's implementations.

template <typename Protocol1, typename Executor1>

friend class basic_socket;

/// Move-construct a basic_socket from a socket of another protocol type.

/**

* This constructor moves a socket from one object to another.

*

* @param other The other basic_socket object from which the move will

* occur.

*

* @note Following the move, the moved-from object is in the same state as if

* constructed using the @c basic_socket(const executor_type&) constructor.

*/

template <typename Protocol1, typename Executor1>

basic_socket(basic_socket<Protocol1, Executor1>&& other,

typename constraint<

is_convertible<Protocol1, Protocol>::value

&& is_convertible<Executor1, Executor>::value

>::type = 0)

: impl_(std::move(other.impl_))

{

}

/// Move-assign a basic_socket from a socket of another protocol type.

/**

* This assignment operator moves a socket from one object to another.

*

* @param other The other basic_socket object from which the move will

* occur.

*

* @note Following the move, the moved-from object is in the same state as if

* constructed using the @c basic_socket(const executor_type&) constructor.

*/

template <typename Protocol1, typename Executor1>

typename constraint<

is_convertible<Protocol1, Protocol>::value

&& is_convertible<Executor1, Executor>::value,

basic_socket&

>::type operator=(basic_socket<Protocol1, Executor1> && other)

{

basic_socket tmp(std::move(other));

impl_ = std::move(tmp.impl_);

return *this;

}

#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)

/// Get the executor associated with the object.

executor_type get_executor() ASIO_NOEXCEPT

{

return impl_.get_executor();

}

#if !defined(ASIO_NO_EXTENSIONS)

/// Get a reference to the lowest layer.

/**

* This function returns a reference to the lowest layer in a stack of

* layers. Since a basic_socket cannot contain any further layers, it simply

* returns a reference to itself.

*

* @return A reference to the lowest layer in the stack of layers. Ownership

* is not transferred to the caller.

*/

lowest_layer_type& lowest_layer()

{

return *this;

}

/// Get a const reference to the lowest layer.

/**

* This function returns a const reference to the lowest layer in a stack of

* layers. Since a basic_socket cannot contain any further layers, it simply

* returns a reference to itself.

*

* @return A const reference to the lowest layer in the stack of layers.

* Ownership is not transferred to the caller.

*/

const lowest_layer_type& lowest_layer() const

{

return *this;

}

#endif // !defined(ASIO_NO_EXTENSIONS)

/// Open the socket using the specified protocol.

/**

* This function opens the socket so that it will use the specified protocol.

*

* @param protocol An object specifying protocol parameters to be used.

*

* @throws asio::system_error Thrown on failure.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* socket.open(asio::ip::tcp::v4());

* @endcode

*/

void open(const protocol_type& protocol = protocol_type())

{

asio::error_code ec;

impl_.get_service().open(impl_.get_implementation(), protocol, ec);

asio::detail::throw_error(ec, "open");

}

/// Open the socket using the specified protocol.

/**

* This function opens the socket so that it will use the specified protocol.

*

* @param protocol An object specifying which protocol is to be used.

*

* @param ec Set to indicate what error occurred, if any.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* asio::error_code ec;

* socket.open(asio::ip::tcp::v4(), ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

ASIO_SYNC_OP_VOID open(const protocol_type& protocol,

asio::error_code& ec)

{

impl_.get_service().open(impl_.get_implementation(), protocol, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Assign an existing native socket to the socket.

/*

* This function opens the socket to hold an existing native socket.

*

* @param protocol An object specifying which protocol is to be used.

*

* @param native_socket A native socket.

*

* @throws asio::system_error Thrown on failure.

*/

void assign(const protocol_type& protocol,

const native_handle_type& native_socket)

{

asio::error_code ec;

impl_.get_service().assign(impl_.get_implementation(),

protocol, native_socket, ec);

asio::detail::throw_error(ec, "assign");

}

/// Assign an existing native socket to the socket.

/*

* This function opens the socket to hold an existing native socket.

*

* @param protocol An object specifying which protocol is to be used.

*

* @param native_socket A native socket.

*

* @param ec Set to indicate what error occurred, if any.

*/

ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,

const native_handle_type& native_socket, asio::error_code& ec)

{

impl_.get_service().assign(impl_.get_implementation(),

protocol, native_socket, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Determine whether the socket is open.

bool is_open() const

{

return impl_.get_service().is_open(impl_.get_implementation());

}

/// Close the socket.

/**

* This function is used to close the socket. Any asynchronous send, receive

* or connect operations will be cancelled immediately, and will complete

* with the asio::error::operation_aborted error.

*

* @throws asio::system_error Thrown on failure. Note that, even if

* the function indicates an error, the underlying descriptor is closed.

*

* @note For portable behaviour with respect to graceful closure of a

* connected socket, call shutdown() before closing the socket.

*/

void close()

{

asio::error_code ec;

impl_.get_service().close(impl_.get_implementation(), ec);

asio::detail::throw_error(ec, "close");

}

/// Close the socket.

/**

* This function is used to close the socket. Any asynchronous send, receive

* or connect operations will be cancelled immediately, and will complete

* with the asio::error::operation_aborted error.

*

* @param ec Set to indicate what error occurred, if any. Note that, even if

* the function indicates an error, the underlying descriptor is closed.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* ...

* asio::error_code ec;

* socket.close(ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*

* @note For portable behaviour with respect to graceful closure of a

* connected socket, call shutdown() before closing the socket.

*/

ASIO_SYNC_OP_VOID close(asio::error_code& ec)

{

impl_.get_service().close(impl_.get_implementation(), ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Release ownership of the underlying native socket.

/**

* This function causes all outstanding asynchronous connect, send and receive

* operations to finish immediately, and the handlers for cancelled operations

* will be passed the asio::error::operation_aborted error. Ownership

* of the native socket is then transferred to the caller.

*

* @throws asio::system_error Thrown on failure.

*

* @note This function is unsupported on Windows versions prior to Windows

* 8.1, and will fail with asio::error::operation_not_supported on

* these platforms.

*/

#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \

&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)

__declspec(deprecated("This function always fails with "

"operation_not_supported when used on Windows versions "

"prior to Windows 8.1."))

#endif

native_handle_type release()

{

asio::error_code ec;

native_handle_type s = impl_.get_service().release(

impl_.get_implementation(), ec);

asio::detail::throw_error(ec, "release");

return s;

}

/// Release ownership of the underlying native socket.

/**

* This function causes all outstanding asynchronous connect, send and receive

* operations to finish immediately, and the handlers for cancelled operations

* will be passed the asio::error::operation_aborted error. Ownership

* of the native socket is then transferred to the caller.

*

* @param ec Set to indicate what error occurred, if any.

*

* @note This function is unsupported on Windows versions prior to Windows

* 8.1, and will fail with asio::error::operation_not_supported on

* these platforms.

*/

#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \

&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)

__declspec(deprecated("This function always fails with "

"operation_not_supported when used on Windows versions "

"prior to Windows 8.1."))

#endif

native_handle_type release(asio::error_code& ec)

{

return impl_.get_service().release(impl_.get_implementation(), ec);

}

/// Get the native socket representation.

/**

* This function may be used to obtain the underlying representation of the

* socket. This is intended to allow access to native socket functionality

* that is not otherwise provided.

*/

native_handle_type native_handle()

{

return impl_.get_service().native_handle(impl_.get_implementation());

}

/// Cancel all asynchronous operations associated with the socket.

/**

* This function causes all outstanding asynchronous connect, send and receive

* operations to finish immediately, and the handlers for cancelled operations

* will be passed the asio::error::operation_aborted error.

*

* @throws asio::system_error Thrown on failure.

*

* @note Calls to cancel() will always fail with

* asio::error::operation_not_supported when run on Windows XP, Windows

* Server 2003, and earlier versions of Windows, unless

* ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has

* two issues that should be considered before enabling its use:

*

* @li It will only cancel asynchronous operations that were initiated in the

* current thread.

*

* @li It can appear to complete without error, but the request to cancel the

* unfinished operations may be silently ignored by the operating system.

* Whether it works or not seems to depend on the drivers that are installed.

*

* For portable cancellation, consider using one of the following

* alternatives:

*

* @li Disable asio's I/O completion port backend by defining

* ASIO_DISABLE_IOCP.

*

* @li Use the close() function to simultaneously cancel the outstanding

* operations and close the socket.

*

* When running on Windows Vista, Windows Server 2008, and later, the

* CancelIoEx function is always used. This function does not have the

* problems described above.

*/

#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \

&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \

&& !defined(ASIO_ENABLE_CANCELIO)

__declspec(deprecated("By default, this function always fails with "

"operation_not_supported when used on Windows XP, Windows Server 2003, "

"or earlier. Consult documentation for details."))

#endif

void cancel()

{

asio::error_code ec;

impl_.get_service().cancel(impl_.get_implementation(), ec);

asio::detail::throw_error(ec, "cancel");

}

/// Cancel all asynchronous operations associated with the socket.

/**

* This function causes all outstanding asynchronous connect, send and receive

* operations to finish immediately, and the handlers for cancelled operations

* will be passed the asio::error::operation_aborted error.

*

* @param ec Set to indicate what error occurred, if any.

*

* @note Calls to cancel() will always fail with

* asio::error::operation_not_supported when run on Windows XP, Windows

* Server 2003, and earlier versions of Windows, unless

* ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has

* two issues that should be considered before enabling its use:

*

* @li It will only cancel asynchronous operations that were initiated in the

* current thread.

*

* @li It can appear to complete without error, but the request to cancel the

* unfinished operations may be silently ignored by the operating system.

* Whether it works or not seems to depend on the drivers that are installed.

*

* For portable cancellation, consider using one of the following

* alternatives:

*

* @li Disable asio's I/O completion port backend by defining

* ASIO_DISABLE_IOCP.

*

* @li Use the close() function to simultaneously cancel the outstanding

* operations and close the socket.

*

* When running on Windows Vista, Windows Server 2008, and later, the

* CancelIoEx function is always used. This function does not have the

* problems described above.

*/

#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \

&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \

&& !defined(ASIO_ENABLE_CANCELIO)

__declspec(deprecated("By default, this function always fails with "

"operation_not_supported when used on Windows XP, Windows Server 2003, "

"or earlier. Consult documentation for details."))

#endif

ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)

{

impl_.get_service().cancel(impl_.get_implementation(), ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Determine whether the socket is at the out-of-band data mark.

/**

* This function is used to check whether the socket input is currently

* positioned at the out-of-band data mark.

*

* @return A bool indicating whether the socket is at the out-of-band data

* mark.

*

* @throws asio::system_error Thrown on failure.

*/

bool at_mark() const

{

asio::error_code ec;

bool b = impl_.get_service().at_mark(impl_.get_implementation(), ec);

asio::detail::throw_error(ec, "at_mark");

return b;

}

/// Determine whether the socket is at the out-of-band data mark.

/**

* This function is used to check whether the socket input is currently

* positioned at the out-of-band data mark.

*

* @param ec Set to indicate what error occurred, if any.

*

* @return A bool indicating whether the socket is at the out-of-band data

* mark.

*/

bool at_mark(asio::error_code& ec) const

{

return impl_.get_service().at_mark(impl_.get_implementation(), ec);

}

/// Determine the number of bytes available for reading.

/**

* This function is used to determine the number of bytes that may be read

* without blocking.

*

* @return The number of bytes that may be read without blocking, or 0 if an

* error occurs.

*

* @throws asio::system_error Thrown on failure.

*/

std::size_t available() const

{

asio::error_code ec;

std::size_t s = impl_.get_service().available(

impl_.get_implementation(), ec);

asio::detail::throw_error(ec, "available");

return s;

}

/// Determine the number of bytes available for reading.

/**

* This function is used to determine the number of bytes that may be read

* without blocking.

*

* @param ec Set to indicate what error occurred, if any.

*

* @return The number of bytes that may be read without blocking, or 0 if an

* error occurs.

*/

std::size_t available(asio::error_code& ec) const

{

return impl_.get_service().available(impl_.get_implementation(), ec);

}

/// Bind the socket to the given local endpoint.

/**

* This function binds the socket to the specified endpoint on the local

* machine.

*

* @param endpoint An endpoint on the local machine to which the socket will

* be bound.

*

* @throws asio::system_error Thrown on failure.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* socket.open(asio::ip::tcp::v4());

* socket.bind(asio::ip::tcp::endpoint(

* asio::ip::tcp::v4(), 12345));

* @endcode

*/

void bind(const endpoint_type& endpoint)

{

asio::error_code ec;

impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);

asio::detail::throw_error(ec, "bind");

}

/// Bind the socket to the given local endpoint.

/**

* This function binds the socket to the specified endpoint on the local

* machine.

*

* @param endpoint An endpoint on the local machine to which the socket will

* be bound.

*

* @param ec Set to indicate what error occurred, if any.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* socket.open(asio::ip::tcp::v4());

* asio::error_code ec;

* socket.bind(asio::ip::tcp::endpoint(

* asio::ip::tcp::v4(), 12345), ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

ASIO_SYNC_OP_VOID bind(const endpoint_type& endpoint,

asio::error_code& ec)

{

impl_.get_service().bind(impl_.get_implementation(), endpoint, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Connect the socket to the specified endpoint.

/**

* This function is used to connect a socket to the specified remote endpoint.

* The function call will block until the connection is successfully made or

* an error occurs.

*

* The socket is automatically opened if it is not already open. If the

* connect fails, and the socket was automatically opened, the socket is

* not returned to the closed state.

*

* @param peer_endpoint The remote endpoint to which the socket will be

* connected.

*

* @throws asio::system_error Thrown on failure.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* asio::ip::tcp::endpoint endpoint(

* asio::ip::address::from_string("1.2.3.4"), 12345);

* socket.connect(endpoint);

* @endcode

*/

void connect(const endpoint_type& peer_endpoint)

{

asio::error_code ec;

if (!is_open())

{

impl_.get_service().open(impl_.get_implementation(),

peer_endpoint.protocol(), ec);

asio::detail::throw_error(ec, "connect");

}

impl_.get_service().connect(impl_.get_implementation(), peer_endpoint, ec);

asio::detail::throw_error(ec, "connect");

}

/// Connect the socket to the specified endpoint.

/**

* This function is used to connect a socket to the specified remote endpoint.

* The function call will block until the connection is successfully made or

* an error occurs.

*

* The socket is automatically opened if it is not already open. If the

* connect fails, and the socket was automatically opened, the socket is

* not returned to the closed state.

*

* @param peer_endpoint The remote endpoint to which the socket will be

* connected.

*

* @param ec Set to indicate what error occurred, if any.

*

* @par Example

* @code

* asio::ip::tcp::socket socket(my_context);

* asio::ip::tcp::endpoint endpoint(

* asio::ip::address::from_string("1.2.3.4"), 12345);

* asio::error_code ec;

* socket.connect(endpoint, ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

ASIO_SYNC_OP_VOID connect(const endpoint_type& peer_endpoint,

asio::error_code& ec)

{

if (!is_open())

{

impl_.get_service().open(impl_.get_implementation(),

peer_endpoint.protocol(), ec);

if (ec)

{

ASIO_SYNC_OP_VOID_RETURN(ec);

}

}

impl_.get_service().connect(impl_.get_implementation(), peer_endpoint, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Start an asynchronous connect.

/**

* This function is used to asynchronously connect a socket to the specified

* remote endpoint. The function call always returns immediately.

*

* The socket is automatically opened if it is not already open. If the

* connect fails, and the socket was automatically opened, the socket is

* not returned to the closed state.

*

* @param peer_endpoint The remote endpoint to which the socket will be

* connected. Copies will be made of the endpoint object as required.

*

* @param handler The handler to be called when the connection operation

* completes. Copies will be made of the handler as required. The function

* signature of the handler must be:

* @code void handler(

* const asio::error_code& error // Result of operation

* ); @endcode

* Regardless of whether the asynchronous operation completes immediately or

* not, the handler will not be invoked from within this function. On

* immediate completion, invocation of the handler will be performed in a

* manner equivalent to using asio::post().

*

* @par Example

* @code

* void connect_handler(const asio::error_code& error)

* {

* if (!error)

* {

* // Connect succeeded.

* }

* }

*

* ...

*

* asio::ip::tcp::socket socket(my_context);

* asio::ip::tcp::endpoint endpoint(

* asio::ip::address::from_string("1.2.3.4"), 12345);

* socket.async_connect(endpoint, connect_handler);

* @endcode

*/

template <

ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))

ConnectHandler ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>

ASIO_INITFN_AUTO_RESULT_TYPE(ConnectHandler,

void (asio::error_code))

async_connect(const endpoint_type& peer_endpoint,

ASIO_MOVE_ARG(ConnectHandler) handler

ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))

{

asio::error_code open_ec;

if (!is_open())

{

const protocol_type protocol = peer_endpoint.protocol();

impl_.get_service().open(impl_.get_implementation(), protocol, open_ec);

}

return async_initiate<ConnectHandler, void (asio::error_code)>(

initiate_async_connect(this), handler, peer_endpoint, open_ec);

}

/// Set an option on the socket.

/**

* This function is used to set an option on the socket.

*

* @param option The new option value to be set on the socket.

*

* @throws asio::system_error Thrown on failure.

*

* @sa SettableSocketOption @n

* asio::socket_base::broadcast @n

* asio::socket_base::do_not_route @n

* asio::socket_base::keep_alive @n

* asio::socket_base::linger @n

* asio::socket_base::receive_buffer_size @n

* asio::socket_base::receive_low_watermark @n

* asio::socket_base::reuse_address @n

* asio::socket_base::send_buffer_size @n

* asio::socket_base::send_low_watermark @n

* asio::ip::multicast::join_group @n

* asio::ip::multicast::leave_group @n

* asio::ip::multicast::enable_loopback @n

* asio::ip::multicast::outbound_interface @n

* asio::ip::multicast::hops @n

* asio::ip::tcp::no_delay

*

* @par Example

* Setting the IPPROTO_TCP/TCP_NODELAY option:

* @code

* asio::ip::tcp::socket socket(my_context);

* ...

* asio::ip::tcp::no_delay option(true);

* socket.set_option(option);

* @endcode

*/

template <typename SettableSocketOption>

void set_option(const SettableSocketOption& option)

{

asio::error_code ec;