//

// basic_socket_acceptor.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_ACCEPTOR_HPP

#define ASIO_BASIC_SOCKET_ACCEPTOR_HPP

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

# pragma once

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

#include "asio/detail/config.hpp"

#include "asio/any_io_executor.hpp"

#include "asio/basic_socket.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/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_ACCEPTOR_FWD_DECL)

#define ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL

// Forward declaration with defaulted arguments.

template <typename Protocol, typename Executor = any_io_executor>

class basic_socket_acceptor;

#endif // !defined(ASIO_BASIC_SOCKET_ACCEPTOR_FWD_DECL)

/// Provides the ability to accept new connections.

/**

* The basic_socket_acceptor class template is used for accepting new socket

* connections.

*

* @par Thread Safety

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

* @e Shared @e objects: Unsafe.

*

* Synchronous @c accept operations are thread safe, if the underlying

* operating system calls are also thread safe. This means that it is permitted

* to perform concurrent calls to synchronous @c accept operations on a single

* socket object. Other synchronous operations, such as @c open or @c close, are

* not thread safe.

*

* @par Example

* Opening a socket acceptor with the SO_REUSEADDR option enabled:

* @code

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

* asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), port);

* acceptor.open(endpoint.protocol());

* acceptor.set_option(asio::ip::tcp::acceptor::reuse_address(true));

* acceptor.bind(endpoint);

* acceptor.listen();

* @endcode

*/

template <typename Protocol, typename Executor>

class basic_socket_acceptor

: public socket_base

{

public:

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

typedef Executor executor_type;

/// Rebinds the acceptor type to another executor.

template <typename Executor1>

struct rebind_executor

{

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

typedef basic_socket_acceptor<Protocol, Executor1> other;

};

/// The native representation of an acceptor.

#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;

/// Construct an acceptor without opening it.

/**

* This constructor creates an acceptor without opening it to listen for new

* connections. The open() function must be called before the acceptor can

* accept new socket connections.

*

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

* dispatch handlers for any asynchronous operations performed on the

* acceptor.

*/

explicit basic_socket_acceptor(const executor_type& ex)

: impl_(0, ex)

{

}

/// Construct an acceptor without opening it.

/**

* This constructor creates an acceptor without opening it to listen for new

* connections. The open() function must be called before the acceptor can

* accept new socket connections.

*

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

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

* asynchronous operations performed on the acceptor.

*/

template <typename ExecutionContext>

explicit basic_socket_acceptor(ExecutionContext& context,

typename constraint<

is_convertible<ExecutionContext&, execution_context&>::value

>::type = 0)

: impl_(0, 0, context)

{

}

/// Construct an open acceptor.

/**

* This constructor creates an acceptor and automatically opens it.

*

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

* dispatch handlers for any asynchronous operations performed on the

* acceptor.

*

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

*

* @throws asio::system_error Thrown on failure.

*/

basic_socket_acceptor(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 an open acceptor.

/**

* This constructor creates an acceptor and automatically opens it.

*

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

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

* asynchronous operations performed on the acceptor.

*

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

*

* @throws asio::system_error Thrown on failure.

*/

template <typename ExecutionContext>

basic_socket_acceptor(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 an acceptor opened on the given endpoint.

/**

* This constructor creates an acceptor and automatically opens it to listen

* for new connections on the specified endpoint.

*

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

* dispatch handlers for any asynchronous operations performed on the

* acceptor.

*

* @param endpoint An endpoint on the local machine on which the acceptor

* will listen for new connections.

*

* @param reuse_addr Whether the constructor should set the socket option

* socket_base::reuse_address.

*

* @throws asio::system_error Thrown on failure.

*

* @note This constructor is equivalent to the following code:

* @code

* basic_socket_acceptor<Protocol> acceptor(my_context);

* acceptor.open(endpoint.protocol());

* if (reuse_addr)

* acceptor.set_option(socket_base::reuse_address(true));

* acceptor.bind(endpoint);

* acceptor.listen();

* @endcode

*/

basic_socket_acceptor(const executor_type& ex,

const endpoint_type& endpoint, bool reuse_addr = true)

: 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");

if (reuse_addr)

{

impl_.get_service().set_option(impl_.get_implementation(),

socket_base::reuse_address(true), ec);

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

}

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

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

impl_.get_service().listen(impl_.get_implementation(),

socket_base::max_listen_connections, ec);

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

}

/// Construct an acceptor opened on the given endpoint.

/**

* This constructor creates an acceptor and automatically opens it to listen

* for new connections on the specified endpoint.

*

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

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

* asynchronous operations performed on the acceptor.

*

* @param endpoint An endpoint on the local machine on which the acceptor

* will listen for new connections.

*

* @param reuse_addr Whether the constructor should set the socket option

* socket_base::reuse_address.

*

* @throws asio::system_error Thrown on failure.

*

* @note This constructor is equivalent to the following code:

* @code

* basic_socket_acceptor<Protocol> acceptor(my_context);

* acceptor.open(endpoint.protocol());

* if (reuse_addr)

* acceptor.set_option(socket_base::reuse_address(true));

* acceptor.bind(endpoint);

* acceptor.listen();

* @endcode

*/

template <typename ExecutionContext>

basic_socket_acceptor(ExecutionContext& context,

const endpoint_type& endpoint, bool reuse_addr = true,

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");

if (reuse_addr)

{

impl_.get_service().set_option(impl_.get_implementation(),

socket_base::reuse_address(true), ec);

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

}

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

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

impl_.get_service().listen(impl_.get_implementation(),

socket_base::max_listen_connections, ec);

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

}

/// Construct a basic_socket_acceptor on an existing native acceptor.

/**

* This constructor creates an acceptor object to hold an existing native

* acceptor.

*

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

* dispatch handlers for any asynchronous operations performed on the

* acceptor.

*

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

*

* @param native_acceptor A native acceptor.

*

* @throws asio::system_error Thrown on failure.

*/

basic_socket_acceptor(const executor_type& ex,

const protocol_type& protocol, const native_handle_type& native_acceptor)

: impl_(0, ex)

{

asio::error_code ec;

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

protocol, native_acceptor, ec);

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

}

/// Construct a basic_socket_acceptor on an existing native acceptor.

/**

* This constructor creates an acceptor object to hold an existing native

* acceptor.

*

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

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

* asynchronous operations performed on the acceptor.

*

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

*

* @param native_acceptor A native acceptor.

*

* @throws asio::system_error Thrown on failure.

*/

template <typename ExecutionContext>

basic_socket_acceptor(ExecutionContext& context,

const protocol_type& protocol, const native_handle_type& native_acceptor,

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_acceptor, ec);

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

}

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

/// Move-construct a basic_socket_acceptor from another.

/**

* This constructor moves an acceptor from one object to another.

*

* @param other The other basic_socket_acceptor 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_acceptor(const executor_type&)

* constructor.

*/

basic_socket_acceptor(basic_socket_acceptor&& other) ASIO_NOEXCEPT

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

{

}

/// Move-assign a basic_socket_acceptor from another.

/**

* This assignment operator moves an acceptor from one object to another.

*

* @param other The other basic_socket_acceptor 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_acceptor(const executor_type&)

* constructor.

*/

basic_socket_acceptor& operator=(basic_socket_acceptor&& other)

{

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

return *this;

}

// All socket acceptors have access to each other's implementations.

template <typename Protocol1, typename Executor1>

friend class basic_socket_acceptor;

/// Move-construct a basic_socket_acceptor from an acceptor of another

/// protocol type.

/**

* This constructor moves an acceptor from one object to another.

*

* @param other The other basic_socket_acceptor 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_acceptor(const executor_type&)

* constructor.

*/

template <typename Protocol1, typename Executor1>

basic_socket_acceptor(basic_socket_acceptor<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_acceptor from an acceptor of another protocol

/// type.

/**

* This assignment operator moves an acceptor from one object to another.

*

* @param other The other basic_socket_acceptor 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_acceptor(const executor_type&)

* constructor.

*/

template <typename Protocol1, typename Executor1>

typename constraint<

is_convertible<Protocol1, Protocol>::value

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

basic_socket_acceptor&

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

{

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

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

return *this;

}

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

/// Destroys the acceptor.

/**

* This function destroys the acceptor, cancelling any outstanding

* asynchronous operations associated with the acceptor as if by calling

* @c cancel.

*/

~basic_socket_acceptor()

{

}

/// Get the executor associated with the object.

executor_type get_executor() ASIO_NOEXCEPT

{

return impl_.get_executor();

}

/// Open the acceptor using the specified protocol.

/**

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

* protocol.

*

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

*

* @throws asio::system_error Thrown on failure.

*

* @par Example

* @code

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

* acceptor.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 acceptor using the specified protocol.

/**

* This function opens the socket acceptor 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::acceptor acceptor(my_context);

* asio::error_code ec;

* acceptor.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);

}

/// Assigns an existing native acceptor to the acceptor.

/*

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

*

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

*

* @param native_acceptor A native acceptor.

*

* @throws asio::system_error Thrown on failure.

*/

void assign(const protocol_type& protocol,

const native_handle_type& native_acceptor)

{

asio::error_code ec;

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

protocol, native_acceptor, ec);

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

}

/// Assigns an existing native acceptor to the acceptor.

/*

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

*

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

*

* @param native_acceptor A native acceptor.

*

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

*/

ASIO_SYNC_OP_VOID assign(const protocol_type& protocol,

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

{

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

protocol, native_acceptor, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Determine whether the acceptor is open.

bool is_open() const

{

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

}

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

/**

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

* local machine.

*

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

* acceptor will be bound.

*

* @throws asio::system_error Thrown on failure.

*

* @par Example

* @code

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

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

* acceptor.open(endpoint.protocol());

* acceptor.bind(endpoint);

* @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 acceptor to the given local endpoint.

/**

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

* local machine.

*

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

* acceptor will be bound.

*

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

*

* @par Example

* @code

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

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

* acceptor.open(endpoint.protocol());

* asio::error_code ec;

* acceptor.bind(endpoint, 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);

}

/// Place the acceptor into the state where it will listen for new

/// connections.

/**

* This function puts the socket acceptor into the state where it may accept

* new connections.

*

* @param backlog The maximum length of the queue of pending connections.

*

* @throws asio::system_error Thrown on failure.

*/

void listen(int backlog = socket_base::max_listen_connections)

{

asio::error_code ec;

impl_.get_service().listen(impl_.get_implementation(), backlog, ec);

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

}

/// Place the acceptor into the state where it will listen for new

/// connections.

/**

* This function puts the socket acceptor into the state where it may accept

* new connections.

*

* @param backlog The maximum length of the queue of pending connections.

*

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

*

* @par Example

* @code

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

* ...

* asio::error_code ec;

* acceptor.listen(asio::socket_base::max_listen_connections, ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

ASIO_SYNC_OP_VOID listen(int backlog, asio::error_code& ec)

{

impl_.get_service().listen(impl_.get_implementation(), backlog, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Close the acceptor.

/**

* This function is used to close the acceptor. Any asynchronous accept

* operations will be cancelled immediately.

*

* A subsequent call to open() is required before the acceptor can again be

* used to again perform socket accept operations.

*

* @throws asio::system_error Thrown on failure.

*/

void close()

{

asio::error_code ec;

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

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

}

/// Close the acceptor.

/**

* This function is used to close the acceptor. Any asynchronous accept

* operations will be cancelled immediately.

*

* A subsequent call to open() is required before the acceptor can again be

* used to again perform socket accept operations.

*

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

*

* @par Example

* @code

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

* ...

* asio::error_code ec;

* acceptor.close(ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

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 acceptor.

/**

* This function causes all outstanding asynchronous accept operations to

* finish immediately, and the handlers for cancelled operations will be

* passed the asio::error::operation_aborted error. Ownership of the

* native acceptor 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 acceptor.

/**

* This function causes all outstanding asynchronous accept operations to

* finish immediately, and the handlers for cancelled operations will be

* passed the asio::error::operation_aborted error. Ownership of the

* native acceptor 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 acceptor representation.

/**

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

* acceptor. This is intended to allow access to native acceptor 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 acceptor.

/**

* 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.

*/

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 acceptor.

/**

* 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.

*/

ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)

{

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

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Set an option on the acceptor.

/**

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

*

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

*

* @throws asio::system_error Thrown on failure.

*

* @sa SettableSocketOption @n

* asio::socket_base::reuse_address

* asio::socket_base::enable_connection_aborted

*

* @par Example

* Setting the SOL_SOCKET/SO_REUSEADDR option:

* @code

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

* ...

* asio::ip::tcp::acceptor::reuse_address option(true);

* acceptor.set_option(option);

* @endcode

*/

template <typename SettableSocketOption>

void set_option(const SettableSocketOption& option)

{

asio::error_code ec;

impl_.get_service().set_option(impl_.get_implementation(), option, ec);

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

}

/// Set an option on the acceptor.

/**

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

*

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

*

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

*

* @sa SettableSocketOption @n

* asio::socket_base::reuse_address

* asio::socket_base::enable_connection_aborted

*

* @par Example

* Setting the SOL_SOCKET/SO_REUSEADDR option:

* @code

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

* ...

* asio::ip::tcp::acceptor::reuse_address option(true);

* asio::error_code ec;

* acceptor.set_option(option, ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

template <typename SettableSocketOption>

ASIO_SYNC_OP_VOID set_option(const SettableSocketOption& option,

asio::error_code& ec)

{

impl_.get_service().set_option(impl_.get_implementation(), option, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Get an option from the acceptor.

/**

* This function is used to get the current value of an option on the

* acceptor.

*

* @param option The option value to be obtained from the acceptor.

*

* @throws asio::system_error Thrown on failure.

*

* @sa GettableSocketOption @n

* asio::socket_base::reuse_address

*

* @par Example

* Getting the value of the SOL_SOCKET/SO_REUSEADDR option:

* @code

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

* ...

* asio::ip::tcp::acceptor::reuse_address option;

* acceptor.get_option(option);

* bool is_set = option.get();

* @endcode

*/

template <typename GettableSocketOption>

void get_option(GettableSocketOption& option) const

{

asio::error_code ec;

impl_.get_service().get_option(impl_.get_implementation(), option, ec);

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

}

/// Get an option from the acceptor.

/**

* This function is used to get the current value of an option on the

* acceptor.

*

* @param option The option value to be obtained from the acceptor.

*

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

*

* @sa GettableSocketOption @n

* asio::socket_base::reuse_address

*

* @par Example

* Getting the value of the SOL_SOCKET/SO_REUSEADDR option:

* @code

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

* ...

* asio::ip::tcp::acceptor::reuse_address option;

* asio::error_code ec;

* acceptor.get_option(option, ec);

* if (ec)

* {

* // An error occurred.

* }

* bool is_set = option.get();

* @endcode

*/

template <typename GettableSocketOption>

ASIO_SYNC_OP_VOID get_option(GettableSocketOption& option,

asio::error_code& ec) const

{

impl_.get_service().get_option(impl_.get_implementation(), option, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Perform an IO control command on the acceptor.

/**

* This function is used to execute an IO control command on the acceptor.

*

* @param command The IO control command to be performed on the acceptor.

*

* @throws asio::system_error Thrown on failure.

*

* @sa IoControlCommand @n

* asio::socket_base::non_blocking_io

*

* @par Example

* Getting the number of bytes ready to read:

* @code

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

* ...

* asio::ip::tcp::acceptor::non_blocking_io command(true);

* socket.io_control(command);

* @endcode

*/

template <typename IoControlCommand>

void io_control(IoControlCommand& command)

{

asio::error_code ec;

impl_.get_service().io_control(impl_.get_implementation(), command, ec);

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

}

/// Perform an IO control command on the acceptor.

/**

* This function is used to execute an IO control command on the acceptor.

*

* @param command The IO control command to be performed on the acceptor.

*

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

*

* @sa IoControlCommand @n

* asio::socket_base::non_blocking_io

*

* @par Example

* Getting the number of bytes ready to read:

* @code

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

* ...

* asio::ip::tcp::acceptor::non_blocking_io command(true);

* asio::error_code ec;

* socket.io_control(command, ec);

* if (ec)

* {

* // An error occurred.

* }

* @endcode

*/

template <typename IoControlCommand>

ASIO_SYNC_OP_VOID io_control(IoControlCommand& command,

asio::error_code& ec)

{

impl_.get_service().io_control(impl_.get_implementation(), command, ec);

ASIO_SYNC_OP_VOID_RETURN(ec);

}

/// Gets the non-blocking mode of the acceptor.

/**

* @returns @c true if the acceptor's synchronous operations will fail with

* asio::error::would_block if they are unable to perform the requested

* operation immediately. If @c false, synchronous operations will block

* until complete.

*

* @note The non-blocking mode has no effect on the behaviour of asynchronous

* operations. Asynchronous operations will never fail with the error

* asio::error::would_block.

*/

bool non_blocking() const

{

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

}

/// Sets the non-blocking mode of the acceptor.

/**

* @param mode If @c true, the acceptor's synchronous operations will fail

* with asio::error::would_block if they are unable to perform the

* requested operation immediately. If @c false, synchronous operations will

* block until complete.

*

* @throws asio::system_error Thrown on failure.

*

* @note The non-blocking mode has no effect on the behaviour of asynchronous

* operations. Asynchronous operations will never fail with the error

* asio::error::would_block.

*/

void non_blocking(bool mode)

{