Boost
C++ Libraries
...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Boost
C++ Libraries
...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
Networking | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Classes
|
Free Functions
Class Templates
Services
|
Socket Options
|
I/O Control Commands
Type Requirements
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Timers |
SSL |
Serial Ports |
Signal Handling |
|||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Classes
Class Templates
Services
Type Requirements
|
Classes
Class Templates
Type Requirements
|
Classes
Class Templates
Services
Serial Port Options
Type Requirements
|
Classes
Class Templates
Services
Type Requirements
|
POSIX-specific |
Windows-specific |
||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Classes
Free Functions
|
Class Templates
Services
Type Requirements
|
Classes
Class Templates
Services
Type Requirements
|
|||||||||||||||||||||||||||||||||
In Boost.Asio, an asynchronous operation is initiated by a function that
is named with the prefix async_.
These functions will be referred to as initiating functions.
All initiating functions in Boost.Asio take a function object meeting handler requirements as the
final parameter. These handlers accept as their first parameter an lvalue
of type const error_code.
Implementations of asynchronous operations in Boost.Asio may call the application
programming interface (API) provided by the operating system. If such an
operating system API call results in an error, the handler will be invoked
with a const error_code
lvalue that evaluates to true. Otherwise the handler will be invoked with
a const error_code
lvalue that evaluates to false.
Unless otherwise noted, when the behaviour of an asynchronous operation is
defined "as if" implemented by a POSIX function,
the handler will be invoked with a value of type error_code
that corresponds to the failure condition described by POSIX
for that function, if any. Otherwise the handler will be invoked with an
implementation-defined error_code
value that reflects the operating system error.
Asynchronous operations will not fail with an error condition that indicates
interruption by a signal (POSIX EINTR).
Asynchronous operations will not fail with any error condition associated
with non-blocking operations (POSIX EWOULDBLOCK,
EAGAIN or EINPROGRESS;
Windows WSAEWOULDBLOCK
or WSAEINPROGRESS).
All asynchronous operations have an associated io_service
object. Where the initiating function is a member function, the associated
io_service is that returned
by the get_io_service()
member function on the same object. Where the initiating function is not
a member function, the associated io_service
is that returned by the get_io_service() member function of the first argument to
the initiating function.
Arguments to initiating functions will be treated as follows:
— If the parameter is declared as a const reference or by-value, the program is not required to guarantee the validity of the argument after the initiating function completes. The implementation may make copies of the argument, and all copies will be destroyed no later than immediately after invocation of the handler.
— If the parameter is declared as a non-const reference, const pointer or non-const pointer, the program must guarantee the validity of the argument until the handler is invoked.
The library implementation is only permitted to make calls to an initiating function's arguments' copy constructors or destructors from a thread that satisfies one of the following conditions:
— The thread is executing any member function of the associated io_service object.
— The thread is executing the destructor of the associated io_service
object.
— The thread is executing one of the io_service
service access functions use_service,
add_service or has_service, where the first argument is
the associated io_service
object.
— The thread is executing any member function, constructor or destructor of
an object of a class defined in this clause, where the object's get_io_service()
member function returns the associated io_service
object.
— The thread is executing any function defined in this clause, where any argument
to the function has an get_io_service() member function that returns the associated
io_service object.
The io_service object associated
with an asynchronous operation will have unfinished work, as if by maintaining
the existence of one or more objects of class io_service::work
constructed using the io_service,
until immediately after the handler for the asynchronous operation has been
invoked.
When an asynchronous operation is complete, the handler for the operation will be invoked as if by:
bch
for the handler, as described below.
ios.post(bch)
to schedule the handler for deferred invocation, where ios is the associated io_service.
This implies that the handler must not be called directly from within the initiating function, even if the asynchronous operation completes immediately.
A bound completion handler is a handler object that contains a copy of a
user-supplied handler, where the user-supplied handler accepts one or more
arguments. The bound completion handler does not accept any arguments, and
contains values to be passed as arguments to the user-supplied handler. The
bound completion handler forwards the asio_handler_allocate(), asio_handler_deallocate(), and asio_handler_invoke() calls to the corresponding functions for
the user-supplied handler. A bound completion handler meets the requirements
for a completion handler.
For example, a bound completion handler for a ReadHandler
may be implemented as follows:
template<class ReadHandler> struct bound_read_handler { bound_read_handler(ReadHandler handler, const error_code& ec, size_t s) : handler_(handler), ec_(ec), s_(s) { } void operator()() { handler_(ec_, s_); } ReadHandler handler_; const error_code ec_; const size_t s_; }; template<class ReadHandler> void* asio_handler_allocate(size_t size, bound_read_handler<ReadHandler>* this_handler) { using boost::asio::asio_handler_allocate; return asio_handler_allocate(size, &this_handler->handler_); } template<class ReadHandler> void asio_handler_deallocate(void* pointer, std::size_t size, bound_read_handler<ReadHandler>* this_handler) { using boost::asio::asio_handler_deallocate; asio_handler_deallocate(pointer, size, &this_handler->handler_); } template<class F, class ReadHandler> void asio_handler_invoke(const F& f, bound_read_handler<ReadHandler>* this_handler) { using boost::asio::asio_handler_invoke; asio_handler_invoke(f, &this_handler->handler_); }
If the thread that initiates an asynchronous operation terminates before the associated handler is invoked, the behaviour is implementation-defined. Specifically, on Windows versions prior to Vista, unfinished operations are cancelled when the initiating thread exits.
The handler argument to an initiating function defines a handler identity.
That is, the original handler argument and any copies of the handler argument
will be considered equivalent. If the implementation needs to allocate storage
for an asynchronous operation, the implementation will perform asio_handler_allocate(size, &h), where size
is the required size in bytes, and h
is the handler. The implementation will perform asio_handler_deallocate(p,
size,
&h), where p
is a pointer to the storage, to deallocate the storage prior to the invocation
of the handler via asio_handler_invoke.
Multiple storage blocks may be allocated for a single asynchronous operation.
By default, initiating functions return void.
This is always the case when the handler is a function pointer, C++11 lambda,
or a function object produced by boost::bind
or std::bind.
For other types, the return type may be customised via a two-step process:
handler_type template, which
is used to determine the true handler type based on the asynchronous
operation's handler's signature.
async_result template, which
is used both to determine the return type and to extract the return value
from the handler.
These two templates have been specialised to provide support for stackful
coroutines and the C++11 std::future
class.
As an example, consider what happens when enabling std::future
support by using the boost::asio::use_future
special value, as in:
std::future<std::size_t> length = my_socket.async_read_some(my_buffer, boost::asio::use_future);
When a handler signature has the form:
void handler(error_code ec, result_type result);
the initiating function returns a std::future
templated on result_type.
In the above async_read_some
example, this is std::size_t. If the asynchronous operation fails,
the error_code is converted
into a system_error exception
and passed back to the caller through the future.
Where a handler signature has the form:
void handler(error_code ec);
the initiating function instead returns std::future<void>.
An accept handler must meet the requirements for a handler.
A value h of an accept handler
class should work correctly in the expression h(ec),
where ec is an lvalue of
type const error_code.
A free function as an accept handler:
void accept_handler( const boost::system::error_code& ec) { ... }
An accept handler function object:
struct accept_handler { ... void operator()( const boost::system::error_code& ec) { ... } ... };
A non-static class member function adapted to an accept handler using bind():
void my_class::accept_handler( const boost::system::error_code& ec) { ... } ... acceptor.async_accept(..., boost::bind(&my_class::accept_handler, this, boost::asio::placeholders::error));
In the table below, a denotes
an asynchronous random access read device object, o
denotes an offset of type boost::uint64_t,
mb denotes an object satisfying
mutable buffer
sequence requirements, and h
denotes an object satisfying read
handler requirements.
Table 7.1. Buffer-oriented asynchronous random-access read device requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Returns the |
|
|
|
Initiates an asynchronous operation to read one or more bytes of
data from the device |
In the table below, a denotes
an asynchronous write stream object, o
denotes an offset of type boost::uint64_t,
cb denotes an object satisfying
constant buffer
sequence requirements, and h
denotes an object satisfying write
handler requirements.
Table 7.2. Buffer-oriented asynchronous random-access write device requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Returns the |
|
|
|
Initiates an asynchronous operation to write one or more bytes
of data to the device |
In the table below, a denotes
an asynchronous read stream object, mb
denotes an object satisfying mutable
buffer sequence requirements, and h
denotes an object satisfying read
handler requirements.
Table 7.3. Buffer-oriented asynchronous read stream requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Returns the |
|
|
|
Initiates an asynchronous operation to read one or more bytes of
data from the stream |
In the table below, a denotes
an asynchronous write stream object, cb
denotes an object satisfying constant
buffer sequence requirements, and h
denotes an object satisfying write
handler requirements.
Table 7.4. Buffer-oriented asynchronous write stream requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Returns the |
|
|
|
Initiates an asynchronous operation to write one or more bytes
of data to the stream |
A buffered handshake handler must meet the requirements for a handler.
A value h of a buffered handshake
handler class should work correctly in the expression h(ec,
s),
where ec is an lvalue of
type const error_code
and s is an lvalue of type
const size_t.
A free function as a buffered handshake handler:
void handshake_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... }
A buffered handshake handler function object:
struct handshake_handler { ... void operator()( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... } ... };
A non-static class member function adapted to a buffered handshake handler
using bind():
void my_class::handshake_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... } ... socket.async_handshake(..., boost::bind(&my_class::handshake_handler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
A completion handler must meet the requirements for a handler.
A value h of a completion
handler class should work correctly in the expression h().
A free function as a completion handler:
void completion_handler() { ... }
A completion handler function object:
struct completion_handler { ... void operator()() { ... } ... };
A non-static class member function adapted to a completion handler using
bind():
void my_class::completion_handler() { ... } ... my_io_service.post(boost::bind(&my_class::completion_handler, this));
A composed connect handler must meet the requirements for a handler.
A value h of a composed connect
handler class should work correctly in the expression h(ec,
i),
where ec is an lvalue of
type const error_code
and i is an lvalue of the
type Iterator used in the
corresponding connect()
or async_connect()` function.
A free function as a composed connect handler:
void connect_handler( const boost::system::error_code& ec, boost::asio::ip::tcp::resolver::iterator iterator) { ... }
A composed connect handler function object:
struct connect_handler { ... template <typename Iterator> void operator()( const boost::system::error_code& ec, Iterator iterator) { ... } ... };
A non-static class member function adapted to a composed connect handler
using bind():
void my_class::connect_handler( const boost::system::error_code& ec, boost::asio::ip::tcp::resolver::iterator iterator) { ... } ... boost::asio::async_connect(..., boost::bind(&my_class::connect_handler, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
A connect handler must meet the requirements for a handler.
A value h of a connect handler
class should work correctly in the expression h(ec),
where ec is an lvalue of
type const error_code.
A free function as a connect handler:
void connect_handler( const boost::system::error_code& ec) { ... }
A connect handler function object:
struct connect_handler { ... void operator()( const boost::system::error_code& ec) { ... } ... };
A non-static class member function adapted to a connect handler using bind():
void my_class::connect_handler( const boost::system::error_code& ec) { ... } ... socket.async_connect(..., boost::bind(&my_class::connect_handler, this, boost::asio::placeholders::error));
In the table below, X denotes
a class containing objects of type T,
a denotes a value of type
X and u
denotes an identifier.
Table 7.5. ConstBufferSequence requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
|
|
|
iterator type pointing to |
|
|
|
post: bool equal_const_buffer_seq( const X& x1, const X& x2) { return distance(x1.begin(), x1.end()) == distance(x2.begin(), x2.end()) && equal(x1.begin(), x1.end(), x2.begin(), equal_buffer); }
and the binary predicate bool equal_buffer( const X::value_type& v1, const X::value_type& v2) { const_buffer b1(v1); const_buffer b2(v2); return buffer_cast<const void*>(b1) == buffer_cast<const void*>(b2) && buffer_size(b1) == buffer_size(b2); }
|
|
|
|
post: distance(a.begin(), a.end()) == distance(u.begin(), u.end()) && equal(a.begin(), a.end(), u.begin(), equal_buffer)
where the binary predicate bool equal_buffer( const X::value_type& v1, const X::value_type& v2) { const_buffer b1(v1); const_buffer b2(v2); return buffer_cast<const void*>(b1) == buffer_cast<const void*>(b2) && buffer_size(b1) == buffer_size(b2); }
|
|
|
|
|
note: the destructor is applied to every element of |
|
|
|
|
|
|
|
A type that meets the requirements for convertibility to a const buffer must
meet the requirements of CopyConstructible
types (C++ Std, 20.1.3), and the requirements of Assignable
types (C++ Std, 23.1).
In the table below, X denotes
a class meeting the requirements for convertibility to a const buffer, a and b
denote values of type X,
and u, v
and w denote identifiers.
Table 7.6. ConvertibleToConstBuffer requirements
|
expression |
postcondition |
|---|---|
|
const_buffer u(a); const_buffer v(a);
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(v) && buffer_size(u) == buffer_size(v)
|
|
const_buffer u(a); const_buffer v = a;
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(v) && buffer_size(u) == buffer_size(v)
|
|
const_buffer u(a); const_buffer v; v = a;
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(v) && buffer_size(u) == buffer_size(v)
|
|
const_buffer u(a); const X& v = a; const_buffer w(v);
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(w) && buffer_size(u) == buffer_size(w)
|
|
const_buffer u(a); X v(a); const_buffer w(v);
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(w) && buffer_size(u) == buffer_size(w)
|
|
const_buffer u(a); X v = a; const_buffer w(v);
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(w) && buffer_size(u) == buffer_size(w)
|
|
const_buffer u(a); X v(b); v = a; const_buffer w(v);
|
buffer_cast<const void*>(u) == buffer_cast<const void*>(w) && buffer_size(u) == buffer_size(w)
|
A type that meets the requirements for convertibility to a mutable buffer
must meet the requirements of CopyConstructible
types (C++ Std, 20.1.3), and the requirements of Assignable
types (C++ Std, 23.1).
In the table below, X denotes
a class meeting the requirements for convertibility to a mutable buffer,
a and b
denote values of type X,
and u, v
and w denote identifiers.
Table 7.7. ConvertibleToMutableBuffer requirements
|
expression |
postcondition |
|---|---|
|
mutable_buffer u(a); mutable_buffer v(a);
|
buffer_cast<void*>(u) == buffer_cast<void*>(v) && buffer_size(u) == buffer_size(v)
|
|
mutable_buffer u(a); mutable_buffer v = a;
|
buffer_cast<void*>(u) == buffer_cast<void*>(v) && buffer_size(u) == buffer_size(v)
|
|
mutable_buffer u(a); mutable_buffer v; v = a;
|
buffer_cast<void*>(u) == buffer_cast<void*>(v) && buffer_size(u) == buffer_size(v)
|
|
mutable_buffer u(a); const X& v = a; mutable_buffer w(v);
|
buffer_cast<void*>(u) == buffer_cast<void*>(w) && buffer_size(u) == buffer_size(w)
|
|
mutable_buffer u(a); X v(a); mutable_buffer w(v);
|
buffer_cast<void*>(u) == buffer_cast<void*>(w) && buffer_size(u) == buffer_size(w)
|
|
mutable_buffer u(a); X v = a; mutable_buffer w(v);
|
buffer_cast<void*>(u) == buffer_cast<void*>(w) && buffer_size(u) == buffer_size(w)
|
|
mutable_buffer u(a); X v(b); v = a; mutable_buffer w(v);
|
buffer_cast<void*>(u) == buffer_cast<void*>(w) && buffer_size(u) == buffer_size(w)
|
A datagram socket service must meet the requirements for a socket service, as well as the additional requirements listed below.
In the table below, X denotes
a datagram socket service class for protocol Protocol, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, e
denotes a value of type Protocol::endpoint,
ec denotes a value of type
error_code, f denotes a value of type socket_base::message_flags, mb
denotes a value satisfying mutable
buffer sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.8. DatagramSocketService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.send_to(b, cb, u, f, ec);
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.async_send(b, cb, u, f, wh);
|
|
pre: |
A descriptor service must meet the requirements for an I/O object service with support for movability, as well as the additional requirements listed below.
In the table below, X denotes
a descriptor service class, a
and ao denote values of type
X, b
and c denote values of type
X::implementation_type, n
denotes a value of type X::native_handle_type,
ec denotes a value of type
error_code, i denotes a value meeting IoControlCommand requirements, and
u and v
denote identifiers.
Table 7.9. DescriptorService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
The implementation-defined native representation of a descriptor.
Must satisfy the requirements of |
|
|
|
From IoObjectService
requirements. |
|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations, as if
by calling |
|
|
a.move_construct(b, c);
|
From IoObjectService
requirements. The underlying native representation is moved from
|
|
|
a.move_assign(b, ao, c);
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations associated
with |
|
|
a.assign(b, n, ec);
|
|
pre: |
|
a.is_open(b);
|
|
|
|
const X& u = a; const X::implementation_type& v = b; u.is_open(v);
|
|
|
|
a.close(b, ec);
|
|
If |
|
a.native_handle(b);
|
|
|
|
a.cancel(b, ec);
|
|
pre: |
|
a.io_control(b, i, ec);
|
|
pre: |
An endpoint must meet the requirements of CopyConstructible
types (C++ Std, 20.1.3), and the requirements of Assignable
types (C++ Std, 23.1).
In the table below, X denotes
an endpoint class, a denotes
a value of type X, s denotes a size in bytes, and u denotes an identifier.
Table 7.10. Endpoint requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
type meeting protocol requirements |
|
|
|
||
|
|
||
|
|
|
|
|
|
a pointer |
Returns a pointer suitable for passing as the address
argument to POSIX functions such as |
|
|
a pointer |
Returns a pointer suitable for passing as the address
argument to POSIX functions such as |
|
|
|
Returns a value suitable for passing as the address_len
argument to POSIX functions such as |
|
|
post: |
|
|
|
|
Returns a value suitable for passing as the address_len
argument to POSIX functions such as |
In the table below, X denotes
a serial port option class, a
denotes a value of X, ec denotes a value of type error_code, and s
denotes a value of implementation-defined type storage
(where storage is the type DCB on Windows and termios
on POSIX platforms), and u
denotes an identifier.
Table 7.11. GettableSerialPortOption requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
|
Retrieves the value of the serial port option from the storage. |
In the table below, X denotes
a socket option class, a
denotes a value of X, p denotes a value that meets the protocol requirements, and
u denotes an identifier.
Table 7.12. GettableSocketOption requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
|
Returns a value suitable for passing as the level
argument to POSIX |
|
|
|
Returns a value suitable for passing as the option_name
argument to POSIX |
|
|
a pointer, convertible to |
Returns a pointer suitable for passing as the option_value
argument to POSIX |
|
|
|
Returns a value suitable for passing as the option_len
argument to POSIX |
|
|
post: |
A handler must meet the requirements of CopyConstructible
types (C++ Std, 20.1.3).
In the table below, X denotes
a handler class, h denotes
a value of X, p denotes a pointer to a block of allocated
memory of type void*,
s denotes the size for a
block of allocated memory, and f
denotes a function object taking no arguments.
Table 7.13. Handler requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
using boost::asio::asio_handler_allocate; asio_handler_allocate(s, &h);
|
|
Returns a pointer to a block of memory of size |
|
using boost::asio::asio_handler_deallocate; asio_handler_deallocate(p, s, &h);
|
Frees a block of memory associated with a pointer |
|
|
using boost::asio::asio_handler_invoke; asio_handler_invoke(f, &h);
|
Causes the function object |
A handle service must meet the requirements for an I/O object service with support for movability, as well as the additional requirements listed below.
In the table below, X denotes
a handle service class, a
and ao denote values of type
X, b
and c denote values of type
X::implementation_type, n
denotes a value of type X::native_handle_type,
ec denotes a value of type
error_code, and u and v
denote identifiers.
Table 7.14. HandleService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
The implementation-defined native representation of a handle. Must
satisfy the requirements of |
|
|
|
From IoObjectService
requirements. |
|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations, as if
by calling |
|
|
a.move_construct(b, c);
|
From IoObjectService
requirements. The underlying native representation is moved from
|
|
|
a.move_assign(b, ao, c);
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations associated
with |
|
|
a.assign(b, n, ec);
|
|
pre: |
|
a.is_open(b);
|
|
|
|
const X& u = a; const X::implementation_type& v = b; u.is_open(v);
|
|
|
|
a.close(b, ec);
|
|
If |
|
a.native_handle(b);
|
|
|
|
a.cancel(b, ec);
|
|
pre: |
A handshake handler must meet the requirements for a handler.
A value h of a handshake
handler class should work correctly in the expression h(ec),
where ec is an lvalue of
type const error_code.
A free function as a handshake handler:
void handshake_handler( const boost::system::error_code& ec) { ... }
A handshake handler function object:
struct handshake_handler { ... void operator()( const boost::system::error_code& ec) { ... } ... };
A non-static class member function adapted to a handshake handler using
bind():
void my_class::handshake_handler( const boost::system::error_code& ec) { ... } ... ssl_stream.async_handshake(..., boost::bind(&my_class::handshake_handler, this, boost::asio::placeholders::error));
An internet protocol must meet the requirements for a protocol as well as the additional requirements listed below.
In the table below, X denotes
an internet protocol class, a
denotes a value of type X,
and b denotes a value of
type X.
Table 7.15. InternetProtocol requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
The type of a resolver for the protocol. |
|
|
|
Returns an object representing the IP version 4 protocol. |
|
|
|
Returns an object representing the IP version 6 protocol. |
|
|
convertible to |
Returns whether two protocol objects are equal. |
|
|
convertible to |
Returns |
In the table below, X denotes
an I/O control command class, a
denotes a value of X, and
u denotes an identifier.
Table 7.16. IoControlCommand requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
|
Returns a value suitable for passing as the request
argument to POSIX |
|
|
a pointer, convertible to |
An I/O object service must meet the requirements for a service, as well as the requirements listed below.
In the table below, X denotes
an I/O object service class, a
and ao denote values of type
X, b
and c denote values of type
X::implementation_type, and u denotes an identifier.
Table 7.17. IoObjectService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
||
|
|
note: |
|
|
a.construct(b);
|
||
|
a.destroy(b);
|
note: |
|
|
a.move_construct(b, c);
|
note: only required for I/O objects that support movability. |
|
|
a.move_assign(b, ao, c);
|
note: only required for I/O objects that support movability. |
In the table below, X denotes
a class containing objects of type T,
a denotes a value of type
X and u
denotes an identifier.
Table 7.18. MutableBufferSequence requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
|
|
|
iterator type pointing to |
|
|
|
post: bool equal_mutable_buffer_seq( const X& x1, const X& x2) { return distance(x1.begin(), x1.end()) == distance(x2.begin(), x2.end()) && equal(x1.begin(), x1.end(), x2.begin(), equal_buffer); }
and the binary predicate bool equal_buffer( const X::value_type& v1, const X::value_type& v2) { mutable_buffer b1(v1); mutable_buffer b2(v2); return buffer_cast<const void*>(b1) == buffer_cast<const void*>(b2) && buffer_size(b1) == buffer_size(b2); }
|
|
|
|
post: distance(a.begin(), a.end()) == distance(u.begin(), u.end()) && equal(a.begin(), a.end(), u.begin(), equal_buffer)
where the binary predicate bool equal_buffer( const X::value_type& v1, const X::value_type& v2) { mutable_buffer b1(v1); mutable_buffer b2(v2); return buffer_cast<const void*>(b1) == buffer_cast<const void*>(b2) && buffer_size(b1) == buffer_size(b2); }
|
|
|
|
|
note: the destructor is applied to every element of |
|
|
|
|
|
|
|
An object handle service must meet the requirements for a handle service, as well as the additional requirements listed below.
In the table below, X denotes
an object handle service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
and wh denotes a value meeting
WaitHandler
requirements.
Table 7.19. ObjectHandleService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
A protocol must meet the requirements of CopyConstructible
types (C++ Std, 20.1.3), and the requirements of Assignable
types (C++ Std, 23.1).
In the table below, X denotes
a protocol class, and a denotes
a value of X.
Table 7.20. Protocol requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
type meeting endpoint requirements |
|
|
|
|
Returns a value suitable for passing as the domain
argument to POSIX |
|
|
|
Returns a value suitable for passing as the type
argument to POSIX |
|
|
|
Returns a value suitable for passing as the protocol
argument to POSIX |
A random access handle service must meet the requirements for a handle service, as well as the additional requirements listed below.
In the table below, X denotes
a random access handle service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
o denotes an offset of type
boost::uint64_t, mb denotes
a value satisfying mutable
buffer sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.21. RandomAccessHandleService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
A raw socket service must meet the requirements for a socket service, as well as the additional requirements listed below.
In the table below, X denotes
a raw socket service class for protocol Protocol, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, e
denotes a value of type Protocol::endpoint,
ec denotes a value of type
error_code, f denotes a value of type socket_base::message_flags, mb
denotes a value satisfying mutable
buffer sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.22. RawSocketService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.send_to(b, cb, u, f, ec);
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.async_send(b, cb, u, f, wh);
|
|
pre: |
A read handler must meet the requirements for a handler.
A value h of a read handler
class should work correctly in the expression h(ec,
s),
where ec is an lvalue of
type const error_code
and s is an lvalue of type
const size_t.
A free function as a read handler:
void read_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... }
A read handler function object:
struct read_handler { ... void operator()( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... } ... };
A non-static class member function adapted to a read handler using bind():
void my_class::read_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... } ... socket.async_read(..., boost::bind(&my_class::read_handler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
A resolve handler must meet the requirements for a handler.
A value h of a resolve handler
class should work correctly in the expression h(ec,
i),
where ec is an lvalue of
type const error_code
and i is an lvalue of type
const ip::basic_resolver_iterator<InternetProtocol>. InternetProtocol
is the template parameter of the resolver_service which is used to
initiate the asynchronous operation.
A free function as a resolve handler:
void resolve_handler( const boost::system::error_code& ec, boost::asio::ip::tcp::resolver::iterator iterator) { ... }
A resolve handler function object:
struct resolve_handler { ... void operator()( const boost::system::error_code& ec, boost::asio::ip::tcp::resolver::iterator iterator) { ... } ... };
A non-static class member function adapted to a resolve handler using bind():
void my_class::resolve_handler( const boost::system::error_code& ec, boost::asio::ip::tcp::resolver::iterator iterator) { ... } ... resolver.async_resolve(..., boost::bind(&my_class::resolve_handler, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
A resolver service must meet the requirements for an I/O object service, as well as the additional requirements listed below.
In the table below, X denotes
a resolver service class for protocol InternetProtocol,
a denotes a value of type
X, b
denotes a value of type X::implementation_type,
q denotes a value of type
ip::basic_resolver_query<InternetProtocol>,
e denotes a value of type
ip::basic_endpoint<InternetProtocol>,
ec denotes a value of type
error_code, and h denotes a value meeting ResolveHandler requirements.
Table 7.23. ResolverService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous resolve operations,
as if by calling |
|
|
a.cancel(b, ec);
|
|
Causes any outstanding asynchronous resolve operations to complete
as soon as possible. Handlers for cancelled operations shall be
passed the error code |
|
a.resolve(b, q, ec);
|
ip::basic_resolver_iterator< InternetProtocol>
|
On success, returns an iterator |
|
a.async_resolve(b, q, h);
|
Initiates an asynchronous resolve operation that is performed via
the |
|
|
a.resolve(b, e, ec);
|
ip::basic_resolver_iterator< InternetProtocol>
|
On success, returns an iterator |
|
a.async_resolve(b, e, h);
|
Initiates an asynchronous resolve operation that is performed via
the |
A sequenced packet socket service must meet the requirements for a socket service, as well as the additional requirements listed below.
In the table below, X denotes
a stream socket service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
f denotes a value of type
socket_base::message_flags, g
denotes an lvalue of type socket_base::message_flags,
mb denotes a value satisfying
mutable buffer
sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.24. StreamSocketService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
A serial port service must meet the requirements for an I/O object service with support for movability, as well as the additional requirements listed below.
In the table below, X denotes
a serial port service class, a
and ao denote values of type
X, d
denotes a serial port device name of type std::string,
b and c
denote values of type X::implementation_type, n
denotes a value of type X::native_handle_type,
ec denotes a value of type
error_code, s denotes a value meeting SettableSerialPortOption requirements,
g denotes a value meeting
GettableSerialPortOption requirements,
mb denotes a value satisfying
mutable buffer
sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements. and
u and v
denote identifiers.
Table 7.25. SerialPortService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
The implementation-defined native representation of a serial port.
Must satisfy the requirements of |
|
|
|
From IoObjectService
requirements. |
|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations, as if
by calling |
|
|
a.move_construct(b, c);
|
From IoObjectService
requirements. The underlying native representation is moved from
|
|
|
a.move_assign(b, ao, c);
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations associated
with |
|
|
const std::string& u = d; a.open(b, u, ec);
|
|
pre: |
|
a.assign(b, n, ec);
|
|
pre: |
|
a.is_open(b);
|
|
|
|
const X& u = a; const X::implementation_type& v = b; u.is_open(v);
|
|
|
|
a.close(b, ec);
|
|
If |
|
a.native_handle(b);
|
|
|
|
a.cancel(b, ec);
|
|
pre: |
|
a.set_option(b, s, ec);
|
|
pre: |
|
a.get_option(b, g, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.get_option(v, g, ec);
|
|
pre: |
|
a.send_break(b, ec);
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
A class is a service if it is publicly derived from another service, or if
it is a class derived from io_service::service
and contains a publicly-accessible declaration as follows:
static io_service::id id;
All services define a one-argument constructor that takes a reference to
the io_service object that
owns the service. This constructor is explicit, preventing
its participation in automatic conversions. For example:
class my_service : public io_service::service { public: static io_service::id id; explicit my_service(io_service& ios); private: virtual void shutdown_service(); ... };
A service's shutdown_service
member function must cause all copies of user-defined handler objects that
are held by the service to be destroyed.
In the table below, X denotes
a serial port option class, a
denotes a value of X, ec denotes a value of type error_code, and s
denotes a value of implementation-defined type storage
(where storage is the type DCB on Windows and termios
on POSIX platforms), and u
denotes an identifier.
Table 7.26. SettableSerialPortOption requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
|
Saves the value of the serial port option to the storage. |
In the table below, X denotes
a socket option class, a
denotes a value of X, p denotes a value that meets the protocol requirements, and
u denotes an identifier.
Table 7.27. SettableSocketOption requirements
|
expression |
type |
assertion/note |
|---|---|---|
|
|
|
Returns a value suitable for passing as the level
argument to POSIX |
|
|
|
Returns a value suitable for passing as the option_name
argument to POSIX |
|
|
a pointer, convertible to |
Returns a pointer suitable for passing as the option_value
argument to POSIX |
|
|
|
Returns a value suitable for passing as the option_len
argument to POSIX |
A shutdown handler must meet the requirements for a handler.
A value h of a shutdown handler
class should work correctly in the expression h(ec),
where ec is an lvalue of
type const error_code.
A free function as a shutdown handler:
void shutdown_handler( const boost::system::error_code& ec) { ... }
A shutdown handler function object:
struct shutdown_handler { ... void operator()( const boost::system::error_code& ec) { ... } ... };
A non-static class member function adapted to a shutdown handler using bind():
void my_class::shutdown_handler( const boost::system::error_code& ec) { ... } ... ssl_stream.async_shutdown( boost::bind(&my_class::shutdown_handler, this, boost::asio::placeholders::error));
A signal handler must meet the requirements for a handler.
A value h of a signal handler
class should work correctly in the expression h(ec,
n),
where ec is an lvalue of
type const error_code
and n is an lvalue of type
const int.
A free function as a signal handler:
void signal_handler( const boost::system::error_code& ec, int signal_number) { ... }
A signal handler function object:
struct signal_handler { ... void operator()( const boost::system::error_code& ec, int signal_number) { ... } ... };
A non-static class member function adapted to a signal handler using bind():
void my_class::signal_handler( const boost::system::error_code& ec, int signal_number) { ... } ... my_signal_set.async_wait( boost::bind(&my_class::signal_handler, this, boost::asio::placeholders::error, boost::asio::placeholders::signal_number));
A signal set service must meet the requirements for an I/O object service, as well as the additional requirements listed below.
In the table below, X denotes
a signal set service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
n denotes a value of type
int, and sh
denotes a value meeting SignalHandler requirements.
Table 7.28. SignalSetService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
From IoObjectService
requirements. |
|
|
|
From IoObjectService
requirements. Implicitly clears the registered signals as if by
calling |
|
|
a.add(b, n, ec);
|
|
|
|
a.remove(b, n, ec);
|
|
|
|
a.clear(b, ec);
|
|
|
|
a.cancel(b, ec);
|
|
|
|
|
|
pre: |
A socket acceptor service must meet the requirements for an I/O object service, as well as the additional requirements listed below.
In the table below, X denotes
a socket acceptor service class for protocol Protocol, a
and ao denote values of type
X, b
and c denote values of type
X::implementation_type, p
denotes a value of type Protocol,
n denotes a value of type
X::native_handle_type, e
denotes a value of type Protocol::endpoint,
ec denotes a value of type
error_code, s denotes a value meeting SettableSocketOption requirements,
g denotes a value meeting
GettableSocketOption
requirements, i denotes a
value meeting IoControlCommand requirements,
k denotes a value of type
basic_socket<Protocol, SocketService>
where SocketService is a
type meeting socket service
requirements, ah denotes
a value meeting AcceptHandler requirements, and
u and v
denote identifiers.
Table 7.29. SocketAcceptorService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
The implementation-defined native representation of a socket acceptor.
Must satisfy the requirements of |
|
|
|
From IoObjectService
requirements. |
|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations, as if
by calling |
|
|
a.move_construct(b, c);
|
From IoObjectService
requirements. The underlying native representation is moved from
|
|
|
a.move_assign(b, ao, c);
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations associated
with |
|
|
a.open(b, p, ec);
|
|
pre: |
|
a.assign(b, p, n, ec);
|
|
pre: |
|
a.is_open(b);
|
|
|
|
const X& u = a; const X::implementation_type& v = b; u.is_open(v);
|
|
|
|
a.close(b, ec);
|
|
If |
|
a.native_handle(b);
|
|
|
|
a.cancel(b, ec);
|
|
pre: |
|
a.set_option(b, s, ec);
|
|
pre: |
|
a.get_option(b, g, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.get_option(v, g, ec);
|
|
pre: |
|
a.io_control(b, i, ec);
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.bind(b, u, ec);
|
|
pre: |
|
a.local_endpoint(b, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.local_endpoint(v, ec);
|
|
pre: |
|
a.accept(b, k, &e, ec);
|
|
pre: |
|
a.accept(b, k, 0, ec);
|
|
pre: |
|
a.async_accept(b, k, &e, ah);
|
pre: |
|
|
a.async_accept(b, k, 0, ah);
|
pre: |
A socket service must meet the requirements for an I/O object service with support for movability, as well as the additional requirements listed below.
In the table below, X denotes
a socket service class for protocol Protocol, a
and ao denote values of type
X, b
and c denote values of type
X::implementation_type, p
denotes a value of type Protocol,
n denotes a value of type
X::native_handle_type, e
denotes a value of type Protocol::endpoint,
ec denotes a value of type
error_code, s denotes a value meeting SettableSocketOption requirements,
g denotes a value meeting
GettableSocketOption
requirements, i denotes a
value meeting IoControlCommand requirements,
h denotes a value of type
socket_base::shutdown_type, ch
denotes a value meeting ConnectHandler requirements, and
u and v
denote identifiers.
Table 7.30. SocketService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
The implementation-defined native representation of a socket. Must
satisfy the requirements of |
|
|
|
From IoObjectService
requirements. |
|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations, as if
by calling |
|
|
a.move_construct(b, c);
|
From IoObjectService
requirements. The underlying native representation is moved from
|
|
|
a.move_assign(b, ao, c);
|
From IoObjectService
requirements. Implicitly cancels asynchronous operations associated
with |
|
|
a.open(b, p, ec);
|
|
pre: |
|
a.assign(b, p, n, ec);
|
|
pre: |
|
a.is_open(b);
|
|
|
|
const X& u = a; const X::implementation_type& v = b; u.is_open(v);
|
|
|
|
a.close(b, ec);
|
|
If |
|
a.native_handle(b);
|
|
|
|
a.cancel(b, ec);
|
|
pre: |
|
a.set_option(b, s, ec);
|
|
pre: |
|
a.get_option(b, g, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.get_option(v, g, ec);
|
|
pre: |
|
a.io_control(b, i, ec);
|
|
pre: |
|
a.at_mark(b, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.at_mark(v, ec);
|
|
pre: |
|
a.available(b, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.available(v, ec);
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.bind(b, u, ec);
|
|
pre: |
|
a.shutdown(b, h, ec);
|
|
pre: |
|
a.local_endpoint(b, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.local_endpoint(v, ec);
|
|
pre: |
|
a.remote_endpoint(b, ec);
|
|
pre: |
|
const X& u = a; const X::implementation_type& v = b; u.remote_endpoint(v, ec);
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.connect(b, u, ec);
|
|
pre: |
|
const typename Protocol::endpoint& u = e; a.async_connect(b, u, ch);
|
pre: |
A stream descriptor service must meet the requirements for a descriptor service, as well as the additional requirements listed below.
In the table below, X denotes
a stream descriptor service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
mb denotes a value satisfying
mutable buffer
sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.31. StreamDescriptorService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
A stream handle service must meet the requirements for a handle service, as well as the additional requirements listed below.
In the table below, X denotes
a stream handle service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
mb denotes a value satisfying
mutable buffer
sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.32. StreamHandleService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
A stream socket service must meet the requirements for a socket service, as well as the additional requirements listed below.
In the table below, X denotes
a stream socket service class, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, ec
denotes a value of type error_code,
f denotes a value of type
socket_base::message_flags, mb
denotes a value satisfying mutable
buffer sequence requirements, rh
denotes a value meeting ReadHandler requirements, cb denotes a value satisfying constant
buffer sequence requirements, and wh
denotes a value meeting WriteHandler requirements.
Table 7.33. StreamSocketService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
|
|
|
pre: |
In the table below, a denotes
a synchronous random-access read device object, o
denotes an offset of type boost::uint64_t,
mb denotes an object satisfying
mutable buffer
sequence requirements, and ec
denotes an object of type error_code.
Table 7.34. Buffer-oriented synchronous random-access read device requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Equivalent to: error_code ec; size_t s = a.read_some_at(o, mb, ec); if (ec) throw system_error(ec); return s;
|
|
|
|
Reads one or more bytes of data from the device |
In the table below, a denotes
a synchronous random-access write device object, o
denotes an offset of type boost::uint64_t,
cb denotes an object satisfying
constant buffer
sequence requirements, and ec
denotes an object of type error_code.
Table 7.35. Buffer-oriented synchronous random-access write device requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Equivalent to: error_code ec; size_t s = a.write_some(o, cb, ec); if (ec) throw system_error(ec); return s;
|
|
|
|
Writes one or more bytes of data to the device |
In the table below, a denotes
a synchronous read stream object, mb
denotes an object satisfying mutable
buffer sequence requirements, and ec
denotes an object of type error_code.
Table 7.36. Buffer-oriented synchronous read stream requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Equivalent to: error_code ec; size_t s = a.read_some(mb, ec); if (ec) throw system_error(ec); return s;
|
|
|
|
Reads one or more bytes of data from the stream |
In the table below, a denotes
a synchronous write stream object, cb
denotes an object satisfying constant
buffer sequence requirements, and ec
denotes an object of type error_code.
Table 7.37. Buffer-oriented synchronous write stream requirements
|
operation |
type |
semantics, pre/post-conditions |
|---|---|---|
|
|
|
Equivalent to: error_code ec; size_t s = a.write_some(cb, ec); if (ec) throw system_error(ec); return s;
|
|
|
|
Writes one or more bytes of data to the stream |
In the table below, X denotes
a time traits class for time type Time,
t, t1,
and t2 denote values of type
Time, and d
denotes a value of type X::duration_type.
Table 7.38. TimeTraits requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
Represents an absolute time. Must support default construction,
and meet the requirements for |
|
|
Represents the difference between two absolute times. Must support
default construction, and meet the requirements for |
|
|
|
|
Returns the current time. |
|
|
|
Returns a new absolute time resulting from adding the duration
|
|
|
|
Returns the duration resulting from subtracting |
|
|
|
Returns whether |
|
|
|
Returns the |
A timer service must meet the requirements for an I/O object service, as well as the additional requirements listed below.
In the table below, X denotes
a timer service class for time type Time
and traits type TimeTraits,
a denotes a value of type
X, b
denotes a value of type X::implementation_type,
t denotes a value of type
Time, d
denotes a value of type TimeTraits::duration_type,
e denotes a value of type
error_code, and h denotes a value meeting WaitHandler requirements.
Table 7.39. TimerService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous wait operations,
as if by calling |
|
|
a.cancel(b, e);
|
|
Causes any outstanding asynchronous wait operations to complete
as soon as possible. Handlers for cancelled operations shall be
passed the error code |
|
|
|
|
|
a.expires_at(b, t, e);
|
|
Implicitly cancels asynchronous wait operations, as if by calling
|
|
|
|
Returns a value equivalent to |
|
a.expires_from_now(b, d, e);
|
|
Equivalent to |
|
a.wait(b, e);
|
|
Sets |
|
a.async_wait(b, h);
|
Initiates an asynchronous wait operation that is performed via
the |
A waitable timer service must meet the requirements for an I/O object service, as well as the additional requirements listed below.
In the table below, X denotes
a waitable timer service class for clock type Clock,
where Clock meets the C++11
clock type requirements, a
denotes a value of type X,
b denotes a value of type
X::implementation_type, t
denotes a value of type Clock::time_point,
d denotes a value of type
Clock::duration, e
denotes a value of type error_code,
and h denotes a value meeting
WaitHandler
requirements.
Table 7.40. WaitableTimerService requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
From IoObjectService
requirements. Implicitly cancels asynchronous wait operations,
as if by calling |
|
|
a.cancel(b, e);
|
|
Causes any outstanding asynchronous wait operations to complete
as soon as possible. Handlers for cancelled operations shall be
passed the error code |
|
|
|
|
|
a.expires_at(b, t, e);
|
|
Implicitly cancels asynchronous wait operations, as if by calling
|
|
|
|
Returns a value equivalent to |
|
a.expires_from_now(b, d, e);
|
|
Equivalent to |
|
a.wait(b, e);
|
|
Sets |
|
a.async_wait(b, h);
|
Initiates an asynchronous wait operation that is performed via
the |
A wait handler must meet the requirements for a handler.
A value h of a wait handler
class should work correctly in the expression h(ec),
where ec is an lvalue of
type const error_code.
A free function as a wait handler:
void wait_handler( const boost::system::error_code& ec) { ... }
A wait handler function object:
struct wait_handler { ... void operator()( const boost::system::error_code& ec) { ... } ... };
A non-static class member function adapted to a wait handler using bind():
void my_class::wait_handler( const boost::system::error_code& ec) { ... } ... socket.async_wait(..., boost::bind(&my_class::wait_handler, this, boost::asio::placeholders::error));
In the table below, X denotes
a wait traits class for clock type Clock,
where Clock meets the C++11
type requirements for a clock, and d
denotes a value of type Clock::duration.
Table 7.41. WaitTraits requirements
|
expression |
return type |
assertion/note |
|---|---|---|
|
|
|
Returns the maximum duration to be used for an individual, implementation-defined wait operation. |
A write handler must meet the requirements for a handler.
A value h of a write handler
class should work correctly in the expression h(ec,
s),
where ec is an lvalue of
type const error_code
and s is an lvalue of type
const size_t.
A free function as a write handler:
void write_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... }
A write handler function object:
struct write_handler { ... void operator()( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... } ... };
A non-static class member function adapted to a write handler using bind():
void my_class::write_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { ... } ... socket.async_write(..., boost::bind(&my_class::write_handler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
template< typename Service> void add_service( io_service & ios, Service * svc);
This function is used to add a service to the io_service.
The io_service
object that owns the service.
The service object. On success, ownership of the service object is
transferred to the io_service. When the io_service
object is destroyed, it will destroy the service object by performing:
delete static_cast<io_service::service*>(svc)
Thrown if a service of the given type is already present in the io_service.
Thrown if the service's owning io_service is not the io_service
object specified by the ios parameter.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Default allocation function for handlers.
void * asio_handler_allocate( std::size_t size, ... );
Asynchronous operations may need to allocate temporary objects. Since asynchronous operations have a handler function object, these temporary objects can be said to be associated with the handler.
Implement asio_handler_allocate and asio_handler_deallocate for your own handlers to provide custom allocation for these temporary objects.
The default implementation of these allocation hooks uses operator
new and operator
delete.
All temporary objects associated with a handler will be deallocated before the upcall to the handler is performed. This allows the same memory to be reused for a subsequent asynchronous operation initiated by the handler.
class my_handler; void* asio_handler_allocate(std::size_t size, my_handler* context) { return ::operator new(size); } void asio_handler_deallocate(void* pointer, std::size_t size, my_handler* context) { ::operator delete(pointer); }
Header: boost/asio/handler_alloc_hook.hpp
Convenience header: boost/asio.hpp
Default deallocation function for handlers.
void asio_handler_deallocate( void * pointer, std::size_t size, ... );
Implement asio_handler_allocate and asio_handler_deallocate for your own handlers to provide custom allocation for the associated temporary objects.
The default implementation of these allocation hooks uses operator
new and operator
delete.
Header: boost/asio/handler_alloc_hook.hpp
Convenience header: boost/asio.hpp
Default invoke function for handlers.
template< typename Function> void asio_handler_invoke( Function & function, ... ); » more... template< typename Function> void asio_handler_invoke( const Function & function, ... ); » more...
Completion handlers for asynchronous operations are invoked by the io_service
associated with the corresponding object (e.g. a socket or deadline_timer).
Certain guarantees are made on when the handler may be invoked, in particular
that a handler can only be invoked from a thread that is currently calling
run()
on the corresponding io_service object. Handlers may
subsequently be invoked through other objects (such as io_service::strand objects) that provide additional
guarantees.
When asynchronous operations are composed from other asynchronous operations, all intermediate handlers should be invoked using the same method as the final handler. This is required to ensure that user-defined objects are not accessed in a way that may violate the guarantees. This hooking function ensures that the invoked method used for the final handler is accessible at each intermediate step.
Implement asio_handler_invoke for your own handlers to specify a custom invocation strategy.
This default implementation invokes the function object like so:
function();
If necessary, the default implementation makes a copy of the function object so that the non-const operator() can be used.
class my_handler; template <typename Function> void asio_handler_invoke(Function function, my_handler* context) { context->strand_.dispatch(function); }
Header: boost/asio/handler_invoke_hook.hpp
Convenience header: boost/asio.hpp
Default handler invocation hook used for non-const function objects.
template< typename Function> void asio_handler_invoke( Function & function, ... );
Default handler invocation hook used for const function objects.
template< typename Function> void asio_handler_invoke( const Function & function, ... );
Default continuation function for handlers.
bool asio_handler_is_continuation( ... );
Asynchronous operations may represent a continuation of the asynchronous control flow associated with the current handler. The implementation can use this knowledge to optimise scheduling of the handler.
Implement asio_handler_is_continuation for your own handlers to indicate when a handler represents a continuation.
The default implementation of the continuation hook returns false.
class my_handler; bool asio_handler_is_continuation(my_handler* context) { return true; }
Header: boost/asio/handler_continuation_hook.hpp
Convenience header: boost/asio.hpp
Asynchronously establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ComposedConnectHandler handler); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ComposedConnectHandler handler); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition, ComposedConnectHandler handler); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ConnectCondition connect_condition, ComposedConnectHandler handler); » more...
Header: boost/asio/connect.hpp
Convenience header: boost/asio.hpp
Asynchronously establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ComposedConnectHandler handler);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's async_connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
The handler to be called when the connect operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. if the sequence is empty, set to // boost::asio::error::not_found. Otherwise, contains the // error from the last connection attempt. const boost::system::error_code& error, // On success, an iterator denoting the successfully // connected endpoint. Otherwise, the end iterator. Iterator iterator );
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().
This overload assumes that a default constructed object of type Iterator represents the end of the sequence.
This is a valid assumption for iterator types such as boost::asio::ip::tcp::resolver::iterator.
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); // ... r.async_resolve(q, resolve_handler); // ... void resolve_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { if (!ec) { boost::asio::async_connect(s, i, connect_handler); } } // ... void connect_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { // ... }
Asynchronously establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ComposedConnectHandler handler);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's async_connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
An iterator pointing to the end of a sequence of endpoints.
The handler to be called when the connect operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. if the sequence is empty, set to // boost::asio::error::not_found. Otherwise, contains the // error from the last connection attempt. const boost::system::error_code& error, // On success, an iterator denoting the successfully // connected endpoint. Otherwise, the end iterator. Iterator iterator );
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().
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); // ... r.async_resolve(q, resolve_handler); // ... void resolve_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { if (!ec) { tcp::resolver::iterator end; boost::asio::async_connect(s, i, end, connect_handler); } } // ... void connect_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { // ... }
Asynchronously establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition, ComposedConnectHandler handler);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's async_connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
A function object that is called prior to each connection attempt. The signature of the function object must be:
Iterator connect_condition( const boost::system::error_code& ec, Iterator next);
The ec parameter
contains the result from the most recent connect operation. Before
the first connection attempt, ec
is always set to indicate success. The next
parameter is an iterator pointing to the next endpoint to be tried.
The function object should return the next iterator, but is permitted
to return a different iterator so that endpoints may be skipped.
The implementation guarantees that the function object will never
be called with the end iterator.
The handler to be called when the connect operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. if the sequence is empty, set to // boost::asio::error::not_found. Otherwise, contains the // error from the last connection attempt. const boost::system::error_code& error, // On success, an iterator denoting the successfully // connected endpoint. Otherwise, the end iterator. Iterator iterator );
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().
This overload assumes that a default constructed object of type Iterator represents the end of the sequence.
This is a valid assumption for iterator types such as boost::asio::ip::tcp::resolver::iterator.
The following connect condition function object can be used to output information about the individual connection attempts:
struct my_connect_condition { template <typename Iterator> Iterator operator()( const boost::system::error_code& ec, Iterator next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next->endpoint() << std::endl; return next; } };
It would be used with the boost::asio::connect
function as follows:
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); // ... r.async_resolve(q, resolve_handler); // ... void resolve_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { if (!ec) { boost::asio::async_connect(s, i, my_connect_condition(), connect_handler); } } // ... void connect_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { if (ec) { // An error occurred. } else { std::cout << "Connected to: " << i->endpoint() << std::endl; } }
Asynchronously establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition, typename ComposedConnectHandler> void-or-deduced async_connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ConnectCondition connect_condition, ComposedConnectHandler handler);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's async_connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
An iterator pointing to the end of a sequence of endpoints.
A function object that is called prior to each connection attempt. The signature of the function object must be:
Iterator connect_condition( const boost::system::error_code& ec, Iterator next);
The ec parameter
contains the result from the most recent connect operation. Before
the first connection attempt, ec
is always set to indicate success. The next
parameter is an iterator pointing to the next endpoint to be tried.
The function object should return the next iterator, but is permitted
to return a different iterator so that endpoints may be skipped.
The implementation guarantees that the function object will never
be called with the end iterator.
The handler to be called when the connect operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. if the sequence is empty, set to // boost::asio::error::not_found. Otherwise, contains the // error from the last connection attempt. const boost::system::error_code& error, // On success, an iterator denoting the successfully // connected endpoint. Otherwise, the end iterator. Iterator iterator );
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().
The following connect condition function object can be used to output information about the individual connection attempts:
struct my_connect_condition { template <typename Iterator> Iterator operator()( const boost::system::error_code& ec, Iterator next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next->endpoint() << std::endl; return next; } };
It would be used with the boost::asio::connect
function as follows:
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); // ... r.async_resolve(q, resolve_handler); // ... void resolve_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { if (!ec) { tcp::resolver::iterator end; boost::asio::async_connect(s, i, end, my_connect_condition(), connect_handler); } } // ... void connect_handler( const boost::system::error_code& ec, tcp::resolver::iterator i) { if (ec) { // An error occurred. } else { std::cout << "Connected to: " << i->endpoint() << std::endl; } }
Start an asynchronous operation to read a certain amount of data from a stream.
template< typename AsyncReadStream, typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, const MutableBufferSequence & buffers, ReadHandler handler); » more... template< typename AsyncReadStream, typename MutableBufferSequence, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, ReadHandler handler); » more... template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, basic_streambuf< Allocator > & b, ReadHandler handler); » more... template< typename AsyncReadStream, typename Allocator, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, ReadHandler handler); » more...
Header: boost/asio/read.hpp
Convenience header: boost/asio.hpp
Start an asynchronous operation to read a certain amount of data from a stream.
template< typename AsyncReadStream, typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. The program must ensure that the stream performs no other read operations (such as async_read, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes copied into the // buffers. If an error occurred, // this will be the number of // bytes successfully transferred // prior to the error. );
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().
To read into a single data buffer use the buffer function as follows:
boost::asio::async_read(s, boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::async_read( s, buffers, boost::asio::transfer_all(), handler);
Start an asynchronous operation to read a certain amount of data from a stream.
template< typename AsyncReadStream, typename MutableBufferSequence, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream. 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.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_read_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async_read_some function.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes copied into the // buffers. If an error occurred, // this will be the number of // bytes successfully transferred // prior to the error. );
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().
To read into a single data buffer use the buffer function as follows:
boost::asio::async_read(s, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous operation to read a certain amount of data from a stream.
template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, basic_streambuf< Allocator > & b, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. The program must ensure that the stream performs no other read operations (such as async_read, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
A basic_streambuf object into
which the data will be read. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes copied into the // buffers. If an error occurred, // this will be the number of // bytes successfully transferred // prior to the error. );
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().
This overload is equivalent to calling:
boost::asio::async_read( s, b, boost::asio::transfer_all(), handler);
Start an asynchronous operation to read a certain amount of data from a stream.
template< typename AsyncReadStream, typename Allocator, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read( AsyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. The program must ensure that the stream performs no other read operations (such as async_read, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
A basic_streambuf object into
which the data will be read. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_read_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's async_read_some function.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes copied into the // buffers. If an error occurred, // this will be the number of // bytes successfully transferred // prior to the error. );
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().
Start an asynchronous operation to read a certain amount of data at the specified offset.
template< typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, ReadHandler handler); » more... template< typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition, ReadHandler handler); » more... template< typename AsyncRandomAccessReadDevice, typename Allocator, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, ReadHandler handler); » more... template< typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, ReadHandler handler); » more...
Header: boost/asio/read_at.hpp
Convenience header: boost/asio.hpp
Start an asynchronous operation to read a certain amount of data at the specified offset.
template< typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's async_read_some_at function.
The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.
The offset at which the data will be read.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes copied into the buffers. If an error // occurred, this will be the number of bytes successfully // transferred prior to the error. std::size_t bytes_transferred );
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().
To read into a single data buffer use the buffer function as follows:
boost::asio::async_read_at(d, 42, boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::async_read_at( d, 42, buffers, boost::asio::transfer_all(), handler);
Start an asynchronous operation to read a certain amount of data at the specified offset.
template< typename AsyncRandomAccessReadDevice, typename MutableBufferSequence, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.
The offset at which the data will be read.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device. 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.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_read_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's async_read_some_at function.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes copied into the buffers. If an error // occurred, this will be the number of bytes successfully // transferred prior to the error. std::size_t bytes_transferred );
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().
To read into a single data buffer use the buffer function as follows:
boost::asio::async_read_at(d, 42, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous operation to read a certain amount of data at the specified offset.
template< typename AsyncRandomAccessReadDevice, typename Allocator, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's async_read_some_at function.
The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.
The offset at which the data will be read.
A basic_streambuf object into
which the data will be read. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes copied into the buffers. If an error // occurred, this will be the number of bytes successfully // transferred prior to the error. std::size_t bytes_transferred );
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().
This overload is equivalent to calling:
boost::asio::async_read_at( d, 42, b, boost::asio::transfer_all(), handler);
Start an asynchronous operation to read a certain amount of data at the specified offset.
template< typename AsyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition, typename ReadHandler> void-or-deduced async_read_at( AsyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, ReadHandler handler);
This function is used to asynchronously read a certain number of bytes of data from a random access device at the specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's async_read_some_at function.
The device from which the data is to be read. The type must support the AsyncRandomAccessReadDevice concept.
The offset at which the data will be read.
A basic_streambuf object into
which the data will be read. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_read_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's async_read_some_at function.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes copied into the buffers. If an error // occurred, this will be the number of bytes successfully // transferred prior to the error. std::size_t bytes_transferred );
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().
Start an asynchronous operation to read data into a streambuf until it contains a delimiter, matches a regular expression, or a function object indicates a match.
template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, char delim, ReadHandler handler); » more... template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const std::string & delim, ReadHandler handler); » more... template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const boost::regex & expr, ReadHandler handler); » more... template< typename AsyncReadStream, typename Allocator, typename MatchCondition, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, ReadHandler handler, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); » more...
Header: boost/asio/read_until.hpp
Convenience header: boost/asio.hpp
Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter.
template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, char delim, ReadHandler handler);
This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. If the streambuf's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async_read, async_read_until, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.
The delimiter character.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // The number of bytes in the streambuf's get // area up to and including the delimiter. // 0 if an error occurred. std::size_t bytes_transferred );
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().
After a successful async_read_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent async_read_until operation to examine.
To asynchronously read data into a streambuf until a newline is encountered:
boost::asio::streambuf b; ... void handler(const boost::system::error_code& e, std::size_t size) { if (!e) { std::istream is(&b); std::string line; std::getline(is, line); ... } } ... boost::asio::async_read_until(s, b, '\n', handler);
After the async_read_until
operation completes successfully, the buffer b
contains the delimiter:
{ 'a', 'b', ..., 'c', '\n', 'd', 'e', ... }
The call to std::getline then extracts the data up to
and including the delimiter, so that the string line
contains:
{ 'a', 'b', ..., 'c', '\n' }
The remaining data is left in the buffer b
as follows:
{ 'd', 'e', ... }
This data may be the start of a new line, to be extracted by a subsequent
async_read_until operation.
Start an asynchronous operation to read data into a streambuf until it contains a specified delimiter.
template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const std::string & delim, ReadHandler handler);
This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. If the streambuf's get area already contains the delimiter, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async_read, async_read_until, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.
The delimiter string.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // The number of bytes in the streambuf's get // area up to and including the delimiter. // 0 if an error occurred. std::size_t bytes_transferred );
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().
After a successful async_read_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent async_read_until operation to examine.
To asynchronously read data into a streambuf until a newline is encountered:
boost::asio::streambuf b; ... void handler(const boost::system::error_code& e, std::size_t size) { if (!e) { std::istream is(&b); std::string line; std::getline(is, line); ... } } ... boost::asio::async_read_until(s, b, "\r\n", handler);
After the async_read_until
operation completes successfully, the buffer b
contains the delimiter:
{ 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... }
The call to std::getline then extracts the data up to
and including the delimiter, so that the string line
contains:
{ 'a', 'b', ..., 'c', '\r', '\n' }
The remaining data is left in the buffer b
as follows:
{ 'd', 'e', ... }
This data may be the start of a new line, to be extracted by a subsequent
async_read_until operation.
Start an asynchronous operation to read data into a streambuf until some part of its data matches a regular expression.
template< typename AsyncReadStream, typename Allocator, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const boost::regex & expr, ReadHandler handler);
This function is used to asynchronously read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. If the streambuf's get area already contains data that matches the regular expression, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async_read, async_read_until, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
A streambuf object into which the data will be read. Ownership of the streambuf is retained by the caller, which must guarantee that it remains valid until the handler is called.
The regular expression.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // The number of bytes in the streambuf's get // area up to and including the substring // that matches the regular. expression. // 0 if an error occurred. std::size_t bytes_transferred );
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().
After a successful async_read_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent async_read_until operation to examine.
To asynchronously read data into a streambuf until a CR-LF sequence is encountered:
boost::asio::streambuf b; ... void handler(const boost::system::error_code& e, std::size_t size) { if (!e) { std::istream is(&b); std::string line; std::getline(is, line); ... } } ... boost::asio::async_read_until(s, b, boost::regex("\r\n"), handler);
After the async_read_until
operation completes successfully, the buffer b
contains the data which matched the regular expression:
{ 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... }
The call to std::getline then extracts the data up to
and including the match, so that the string line
contains:
{ 'a', 'b', ..., 'c', '\r', '\n' }
The remaining data is left in the buffer b
as follows:
{ 'd', 'e', ... }
This data may be the start of a new line, to be extracted by a subsequent
async_read_until operation.
Start an asynchronous operation to read data into a streambuf until a function object indicates a match.
template< typename AsyncReadStream, typename Allocator, typename MatchCondition, typename ReadHandler> void-or-deduced async_read_until( AsyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, ReadHandler handler, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0);
This function is used to asynchronously read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_read_some function, and is known as a composed operation. If the match condition function object already indicates a match, this asynchronous operation completes immediately. The program must ensure that the stream performs no other read operations (such as async_read, async_read_until, the stream's async_read_some function, or any other composed operations that perform reads) until this operation completes.
The stream from which the data is to be read. The type must support the AsyncReadStream concept.
A streambuf object into which the data will be read.
The function object to be called to determine whether a match exists. The signature of the function object must be:
pair<iterator, bool> match_condition(iterator begin, iterator end);
where iterator represents
the type:
buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
The iterator parameters begin
and end define the
range of bytes to be scanned to determine whether there is a match.
The first member
of the return value is an iterator marking one-past-the-end of the
bytes that have been consumed by the match function. This iterator
is used to calculate the begin
parameter for any subsequent invocation of the match condition. The
second member of
the return value is true if a match has been found, false otherwise.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // The number of bytes in the streambuf's get // area that have been fully consumed by the // match function. O if an error occurred. std::size_t bytes_transferred );
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().
After a successful async_read_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent async_read_until operation to examine.
The default implementation of the is_match_condition
type trait evaluates to true for function pointers and function objects
with a result_type typedef.
It must be specialised for other user-defined function objects.
To asynchronously read data into a streambuf until whitespace is encountered:
typedef boost::asio::buffers_iterator< boost::asio::streambuf::const_buffers_type> iterator; std::pair<iterator, bool> match_whitespace(iterator begin, iterator end) { iterator i = begin; while (i != end) if (std::isspace(*i++)) return std::make_pair(i, true); return std::make_pair(i, false); } ... void handler(const boost::system::error_code& e, std::size_t size); ... boost::asio::streambuf b; boost::asio::async_read_until(s, b, match_whitespace, handler);
To asynchronously read data into a streambuf until a matching character is found:
class match_char { public: explicit match_char(char c) : c_(c) {} template <typename Iterator> std::pair<Iterator, bool> operator()( Iterator begin, Iterator end) const { Iterator i = begin; while (i != end) if (c_ == *i++) return std::make_pair(i, true); return std::make_pair(i, false); } private: char c_; }; namespace asio { template <> struct is_match_condition<match_char> : public boost::true_type {}; } // namespace asio ... void handler(const boost::system::error_code& e, std::size_t size); ... boost::asio::streambuf b; boost::asio::async_read_until(s, b, match_char('a'), handler);
An interface for customising the behaviour of an initiating function.
template< typename Handler> class async_result
|
Name |
Description |
|---|---|
|
The return type of the initiating function. |
|
Name |
Description |
|---|---|
|
Construct an async result from a given handler. |
|
|
Obtain the value to be returned from the initiating function. |
This template may be specialised for user-defined handler types.
Header: boost/asio/async_result.hpp
Convenience header: boost/asio.hpp
Construct an async result from a given handler.
async_result( Handler & );
When using a specalised async_result, the constructor
has an opportunity to initialise some state associated with the handler,
which is then returned from the initiating function.
The return type of the initiating function.
typedef void type;
Header: boost/asio/async_result.hpp
Convenience header: boost/asio.hpp
Start an asynchronous operation to write a certain amount of data to a stream.
template< typename AsyncWriteStream, typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, const ConstBufferSequence & buffers, WriteHandler handler); » more... template< typename AsyncWriteStream, typename ConstBufferSequence, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, WriteHandler handler); » more... template< typename AsyncWriteStream, typename Allocator, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, basic_streambuf< Allocator > & b, WriteHandler handler); » more... template< typename AsyncWriteStream, typename Allocator, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, WriteHandler handler); » more...
Header: boost/asio/write.hpp
Convenience header: boost/asio.hpp
Start an asynchronous operation to write all of the supplied data to a stream.
template< typename AsyncWriteStream, typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_write_some function, and is known as a composed operation. The program must ensure that the stream performs no other write operations (such as async_write, the stream's async_write_some function, or any other composed operations that perform writes) until this operation completes.
The stream to which the data is to be written. The type must support the AsyncWriteStream concept.
One or more buffers containing the data to be written. 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written from the // buffers. If an error occurred, // this will be less than the sum // of the buffer sizes. );
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().
To write a single data buffer use the buffer function as follows:
boost::asio::async_write(s, boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Start an asynchronous operation to write a certain amount of data to a stream.
template< typename AsyncWriteStream, typename ConstBufferSequence, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's async_write_some function, and is known as a composed operation. The program must ensure that the stream performs no other write operations (such as async_write, the stream's async_write_some function, or any other composed operations that perform writes) until this operation completes.
The stream to which the data is to be written. The type must support the AsyncWriteStream concept.
One or more buffers containing the data to be written. 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.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_write_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async_write_some function.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written from the // buffers. If an error occurred, // this will be less than the sum // of the buffer sizes. );
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().
To write a single data buffer use the buffer function as follows:
boost::asio::async_write(s, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Start an asynchronous operation to write all of the supplied data to a stream.
template< typename AsyncWriteStream, typename Allocator, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, basic_streambuf< Allocator > & b, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the stream's async_write_some function, and is known as a composed operation. The program must ensure that the stream performs no other write operations (such as async_write, the stream's async_write_some function, or any other composed operations that perform writes) until this operation completes.
The stream to which the data is to be written. The type must support the AsyncWriteStream concept.
A basic_streambuf object from
which data will be written. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written from the // buffers. If an error occurred, // this will be less than the sum // of the buffer sizes. );
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().
Start an asynchronous operation to write a certain amount of data to a stream.
template< typename AsyncWriteStream, typename Allocator, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write( AsyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a stream. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the stream's async_write_some function, and is known as a composed operation. The program must ensure that the stream performs no other write operations (such as async_write, the stream's async_write_some function, or any other composed operations that perform writes) until this operation completes.
The stream to which the data is to be written. The type must support the AsyncWriteStream concept.
A basic_streambuf object from
which data will be written. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_write_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's async_write_some function.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written from the // buffers. If an error occurred, // this will be less than the sum // of the buffer sizes. );
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().
Start an asynchronous operation to write a certain amount of data at the specified offset.
template< typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, WriteHandler handler); » more... template< typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition, WriteHandler handler); » more... template< typename AsyncRandomAccessWriteDevice, typename Allocator, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, WriteHandler handler); » more... template< typename AsyncRandomAccessWriteDevice, typename Allocator, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, WriteHandler handler); » more...
Header: boost/asio/write_at.hpp
Convenience header: boost/asio.hpp
Start an asynchronous operation to write all of the supplied data at the specified offset.
template< typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's async_write_some_at function, and is known as a composed operation. The program must ensure that the device performs no overlapping write operations (such as async_write_at, the device's async_write_some_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
One or more buffers containing the data to be written. 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes written from the buffers. If an error // occurred, this will be less than the sum of the buffer sizes. std::size_t bytes_transferred );
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().
To write a single data buffer use the buffer function as follows:
boost::asio::async_write_at(d, 42, boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Start an asynchronous operation to write a certain amount of data at the specified offset.
template< typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's async_write_some_at function, and is known as a composed operation. The program must ensure that the device performs no overlapping write operations (such as async_write_at, the device's async_write_some_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
One or more buffers containing the data to be written. 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.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_write_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's async_write_some_at function.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes written from the buffers. If an error // occurred, this will be less than the sum of the buffer sizes. std::size_t bytes_transferred );
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().
To write a single data buffer use the buffer function as follows:
boost::asio::async_write_at(d, 42, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Start an asynchronous operation to write all of the supplied data at the specified offset.
template< typename AsyncRandomAccessWriteDevice, typename Allocator, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the device's async_write_some_at function, and is known as a composed operation. The program must ensure that the device performs no overlapping write operations (such as async_write_at, the device's async_write_some_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
A basic_streambuf object from
which data will be written. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes written from the buffers. If an error // occurred, this will be less than the sum of the buffer sizes. std::size_t bytes_transferred );
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().
Start an asynchronous operation to write a certain amount of data at the specified offset.
template< typename AsyncRandomAccessWriteDevice, typename Allocator, typename CompletionCondition, typename WriteHandler> void-or-deduced async_write_at( AsyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, WriteHandler handler);
This function is used to asynchronously write a certain number of bytes of data to a random access device at a specified offset. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the device's async_write_some_at function, and is known as a composed operation. The program must ensure that the device performs no overlapping write operations (such as async_write_at, the device's async_write_some_at function, or any other composed operations that perform writes) until this operation completes. Operations are overlapping if the regions defined by their offsets, and the numbers of bytes to write, intersect.
The device to which the data is to be written. The type must support the AsyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
A basic_streambuf object from
which data will be written. Ownership of the streambuf is retained
by the caller, which must guarantee that it remains valid until the
handler is called.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest async_write_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's async_write_some_at function.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( // Result of operation. const boost::system::error_code& error, // Number of bytes written from the buffers. If an error // occurred, this will be less than the sum of the buffer sizes. std::size_t bytes_transferred );
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().
Provides datagram-oriented socket functionality.
template< typename Protocol, typename DatagramSocketService = datagram_socket_service<Protocol>> class basic_datagram_socket : public basic_socket< Protocol, DatagramSocketService >
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_datagram_socket without opening it. Construct and open a basic_datagram_socket. Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. Construct a basic_datagram_socket on an existing native socket. Move-construct a basic_datagram_socket from another. Move-construct a basic_datagram_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_datagram_socket from another. Move-assign a basic_datagram_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive a datagram with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send a datagram to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_datagram_socket class template
provides asynchronous and blocking datagram-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket);
Inherited from basic_socket.
Assign an existing native socket to the socket.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Inherited from basic_socket.
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( const endpoint_type & peer_endpoint, ConnectHandler handler);
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.
The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.
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:
void handler( const boost::system::error_code& error // Result of operation );
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().
void connect_handler(const boost::system::error_code& error) { if (!error) { // Connect succeeded. } } ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.async_connect(endpoint, connect_handler);
Start an asynchronous receive on a connected socket.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, ReadHandler handler); » more... template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler); » more...
Start an asynchronous receive on a connected socket.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
The async_receive operation can only be used with a connected socket. Use the async_receive_from function to receive data on an unconnected datagram socket.
To receive into a single data buffer use the buffer function as follows:
socket.async_receive(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive on a connected socket.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler);
This function is used to asynchronously receive data from the datagram socket. The function call always returns immediately.
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.
Flags specifying how the receive call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
The async_receive operation can only be used with a connected socket. Use the async_receive_from function to receive data on an unconnected datagram socket.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, ReadHandler handler); » more... template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, ReadHandler handler); » more...
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, ReadHandler handler);
This function is used to asynchronously receive a datagram. The function call always returns immediately.
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.
An endpoint object that receives the endpoint of the remote sender of the datagram. Ownership of the sender_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
To receive into a single data buffer use the buffer function as follows:
socket.async_receive_from( boost::asio::buffer(data, size), sender_endpoint, handler);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, ReadHandler handler);
This function is used to asynchronously receive a datagram. The function call always returns immediately.
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.
An endpoint object that receives the endpoint of the remote sender of the datagram. Ownership of the sender_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.
Flags specifying how the receive call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
Start an asynchronous send on a connected socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, WriteHandler handler); » more... template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler); » more...
Start an asynchronous send on a connected socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously send data on the datagram socket. The function call always returns immediately.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
The async_send operation can only be used with a connected socket. Use the async_send_to function to send data on an unconnected datagram socket.
To send a single data buffer use the buffer function as follows:
socket.async_send(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous send on a connected socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
This function is used to asynchronously send data on the datagram socket. The function call always returns immediately.
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.
Flags specifying how the send call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
The async_send operation can only be used with a connected socket. Use the async_send_to function to send data on an unconnected datagram socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, WriteHandler handler); » more... template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, WriteHandler handler); » more...
Start an asynchronous send.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, WriteHandler handler);
This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately.
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.
The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
To send a single data buffer use the buffer function as follows:
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);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous send.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, WriteHandler handler);
This function is used to asynchronously send a datagram to the specified remote endpoint. The function call always returns immediately.
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.
Flags specifying how the send call is to be made.
The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const; » more... bool at_mark( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
A bool indicating whether the socket is at the out-of-band data mark.
Thrown on failure.
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark( boost::system::error_code & ec) const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
Set to indicate what error occurred, if any.
A bool indicating whether the socket is at the out-of-band data mark.
Determine the number of bytes available for reading.
std::size_t available() const; » more... std::size_t available( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available() const;
This function is used to determine the number of bytes that may be read without blocking.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Thrown on failure.
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available( boost::system::error_code & ec) const;
This function is used to determine the number of bytes that may be read without blocking.
Set to indicate what error occurred, if any.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Construct a basic_datagram_socket without
opening it.
explicit basic_datagram_socket( boost::asio::io_service & io_service); » more...
Construct and open a basic_datagram_socket.
basic_datagram_socket( boost::asio::io_service & io_service, const protocol_type & protocol); » more...
Construct a basic_datagram_socket, opening
it and binding it to the given local endpoint.
basic_datagram_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint); » more...
Construct a basic_datagram_socket on an existing
native socket.
basic_datagram_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket); » more...
Move-construct a basic_datagram_socket from another.
basic_datagram_socket( basic_datagram_socket && other); » more...
Move-construct a basic_datagram_socket from a socket
of another protocol type.
template< typename Protocol1, typename DatagramSocketService1> basic_datagram_socket( basic_datagram_socket< Protocol1, DatagramSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0); » more...
Construct a basic_datagram_socket without
opening it.
basic_datagram_socket( boost::asio::io_service & io_service);
This constructor creates a datagram socket without opening it. The open()
function must be called before data can be sent or received on the socket.
The io_service object that
the datagram socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
Construct and open a basic_datagram_socket.
basic_datagram_socket( boost::asio::io_service & io_service, const protocol_type & protocol);
This constructor creates and opens a datagram socket.
The io_service object that
the datagram socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An object specifying protocol parameters to be used.
Thrown on failure.
Construct a basic_datagram_socket, opening
it and binding it to the given local endpoint.
basic_datagram_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint);
This constructor creates a datagram 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.
The io_service object that
the datagram socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An endpoint on the local machine to which the datagram socket will be bound.
Thrown on failure.
Construct a basic_datagram_socket on an
existing native socket.
basic_datagram_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket);
This constructor creates a datagram socket object to hold an existing native socket.
The io_service object that
the datagram socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An object specifying protocol parameters to be used.
The new underlying socket implementation.
Thrown on failure.
Move-construct a basic_datagram_socket from another.
basic_datagram_socket( basic_datagram_socket && other);
This constructor moves a datagram socket from one object to another.
The other basic_datagram_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_datagram_socket(io_service&) constructor.
Move-construct a basic_datagram_socket from a
socket of another protocol type.
template< typename Protocol1, typename DatagramSocketService1> basic_datagram_socket( basic_datagram_socket< Protocol1, DatagramSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
This constructor moves a datagram socket from one object to another.
The other basic_datagram_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_datagram_socket(io_service&) constructor.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345));
Inherited from basic_socket.
Bind the socket to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); boost::system::error_code ec; socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345), ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the socket.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Close the socket.
void close();
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Inherited from basic_socket.
Close the socket.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.close(ec); if (ec) { // An error occurred. }
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_endpoint); » more... boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_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.
The remote endpoint to which the socket will be connected.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.connect(endpoint);
Inherited from basic_socket.
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec);
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.
The remote endpoint to which the socket will be connected.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); boost::system::error_code ec; socket.connect(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the socket.
void get_option( GettableSocketOption & option) const; » more... boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; socket.get_option(option); bool is_set = option.value();
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; boost::system::error_code ec; socket.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.value();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
void io_control( IoControlCommand & command); » more... boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; socket.io_control(command); std::size_t bytes_readable = command.get();
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Get the local endpoint of the socket.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the socket.
An object that represents the local endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec); if (ec) { // An error occurred. }
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from basic_socket.
Get a reference to the lowest layer.
lowest_layer_type & 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.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
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.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
A basic_socket is always the lowest
layer.
typedef basic_socket< Protocol, DatagramSocketService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
Inherited from basic_socket.
(Deprecated: Use native_handle().) Get the native socket representation.
native_type native();
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.
Inherited from basic_socket.
Get the native socket representation.
native_handle_type native_handle();
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.
The native representation of a socket.
typedef DatagramSocketService::native_handle_type native_handle_type;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
true if the underlying socket
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
(Deprecated: Use native_handle_type.) The native representation of a socket.
typedef DatagramSocketService::native_handle_type native_type;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking() const; » more...
Sets the non-blocking mode of the socket.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the socket.
bool non_blocking() const;
true if the socket's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
void non_blocking( bool mode);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket so that it will use the specified protocol.
An object specifying protocol parameters to be used.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4());
Inherited from basic_socket.
Open the socket using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::system::error_code ec; socket.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Move-assign a basic_datagram_socket from another.
basic_datagram_socket & operator=( basic_datagram_socket && other); » more...
Move-assign a basic_datagram_socket from a socket
of another protocol type.
template< typename Protocol1, typename DatagramSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_datagram_socket >::type & operator=( basic_datagram_socket< Protocol1, DatagramSocketService1 > && other); » more...
Move-assign a basic_datagram_socket from another.
basic_datagram_socket & operator=( basic_datagram_socket && other);
This assignment operator moves a datagram socket from one object to another.
The other basic_datagram_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_datagram_socket(io_service&) constructor.
Move-assign a basic_datagram_socket from a
socket of another protocol type.
template< typename Protocol1, typename DatagramSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_datagram_socket >::type & operator=( basic_datagram_socket< Protocol1, DatagramSocketService1 > && other);
This assignment operator moves a datagram socket from one object to another.
The other basic_datagram_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_datagram_socket(io_service&) constructor.
typedef Protocol protocol_type;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags); » more... template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers);
This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
The number of bytes received.
Thrown on failure.
The receive operation can only be used with a connected socket. Use the receive_from function to receive data on an unconnected datagram socket.
To receive into a single data buffer use the buffer function as follows:
socket.receive(boost::asio::buffer(data, size));
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags);
This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
The number of bytes received.
Thrown on failure.
The receive operation can only be used with a connected socket. Use the receive_from function to receive data on an unconnected datagram socket.
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
This function is used to receive data on the datagram socket. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
Set to indicate what error occurred, if any.
The number of bytes received.
The receive operation can only be used with a connected socket. Use the receive_from function to receive data on an unconnected datagram socket.
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Receive a datagram with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint); » more... template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags); » more... 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); » more...
Receive a datagram with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint);
This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
An endpoint object that receives the endpoint of the remote sender of the datagram.
The number of bytes received.
Thrown on failure.
To receive into a single data buffer use the buffer function as follows:
boost::asio::ip::udp::endpoint sender_endpoint; socket.receive_from( boost::asio::buffer(data, size), sender_endpoint);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive a datagram with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags);
This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
An endpoint object that receives the endpoint of the remote sender of the datagram.
Flags specifying how the receive call is to be made.
The number of bytes received.
Thrown on failure.
Receive a datagram with the endpoint of the sender.
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);
This function is used to receive a datagram. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
An endpoint object that receives the endpoint of the remote sender of the datagram.
Flags specifying how the receive call is to be made.
Set to indicate what error occurred, if any.
The number of bytes received.
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const; » more... endpoint_type remote_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const;
This function is used to obtain the remote endpoint of the socket.
An object that represents the remote endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the remote endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers);
This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.
One ore more data buffers to be sent on the socket.
The number of bytes sent.
Thrown on failure.
The send operation can only be used with a connected socket. Use the send_to function to send data on an unconnected datagram socket.
To send a single data buffer use the buffer function as follows:
socket.send(boost::asio::buffer(data, size));
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags);
This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.
One ore more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
The number of bytes sent.
Thrown on failure.
The send operation can only be used with a connected socket. Use the send_to function to send data on an unconnected datagram socket.
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
This function is used to send data on the datagram socket. The function call will block until the data has been sent successfully or an error occurs.
One or more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
Set to indicate what error occurred, if any.
The number of bytes sent.
The send operation can only be used with a connected socket. Use the send_to function to send data on an unconnected datagram socket.
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
Send a datagram to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination); » more... template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags); » more... 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); » more...
Send a datagram to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination);
This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
One or more data buffers to be sent to the remote endpoint.
The remote endpoint to which the data will be sent.
The number of bytes sent.
Thrown on failure.
To send a single data buffer use the buffer function as follows:
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);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send a datagram to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags);
This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
One or more data buffers to be sent to the remote endpoint.
The remote endpoint to which the data will be sent.
Flags specifying how the send call is to be made.
The number of bytes sent.
Thrown on failure.
Send a datagram to the specified endpoint.
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);
This function is used to send a datagram to the specified remote endpoint. The function call will block until the data has been sent successfully or an error occurs.
One or more data buffers to be sent to the remote endpoint.
The remote endpoint to which the data will be sent.
Flags specifying how the send call is to be made.
Set to indicate what error occurred, if any.
The number of bytes sent.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef DatagramSocketService service_type;
Header: boost/asio/basic_datagram_socket.hpp
Convenience header: boost/asio.hpp
void set_option( const SettableSocketOption & option); » more... boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Thrown on failure.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Set to indicate what error occurred, if any.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); boost::system::error_code ec; socket.set_option(option, ec); if (ec) { // An error occurred. }
Disable sends or receives on the socket.
void shutdown( shutdown_type what); » more... boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Disable sends or receives on the socket.
void shutdown( shutdown_type what);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Thrown on failure.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
Inherited from basic_socket.
Disable sends or receives on the socket.
boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Set to indicate what error occurred, if any.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Provides waitable timer functionality.
template< typename Time, typename TimeTraits = boost::asio::time_traits<Time>, typename TimerService = deadline_timer_service<Time, TimeTraits>> class basic_deadline_timer : public basic_io_object< TimerService >
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
The time type. |
|
|
The time traits type. |
|
Name |
Description |
|---|---|
|
Start an asynchronous wait on the timer. |
|
|
Constructor. Constructor to set a particular expiry time as an absolute time. Constructor to set a particular expiry time relative to now. |
|
|
Cancel any asynchronous operations that are waiting on the timer. |
|
|
Cancels one asynchronous operation that is waiting on the timer. |
|
|
Get the timer's expiry time as an absolute time. Set the timer's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the timer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Perform a blocking wait on the timer. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_deadline_timer class template
provides the ability to perform a blocking or asynchronous wait for a timer
to expire.
A deadline timer is always in one of two states: "expired" or "not
expired". If the wait() or async_wait() function is called on an expired timer,
the wait operation will complete immediately.
Most applications will use the deadline_timer typedef.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing a blocking wait:
// Construct a timer without setting an expiry time. boost::asio::deadline_timer timer(io_service); // Set an expiry time relative to now. timer.expires_from_now(boost::posix_time::seconds(5)); // Wait for the timer to expire. timer.wait();
Performing an asynchronous wait:
void handler(const boost::system::error_code& error) { if (!error) { // Timer expired. } } ... // Construct a timer with an absolute expiry time. boost::asio::deadline_timer timer(io_service, boost::posix_time::time_from_string("2005-12-07 23:59:59.000")); // Start an asynchronous wait. timer.async_wait(handler);
Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
void on_some_event() { if (my_timer.expires_from_now(seconds(5)) > 0) { // We managed to cancel the timer. Start new asynchronous wait. my_timer.async_wait(on_timeout); } else { // Too late, timer has already expired! } } void on_timeout(const boost::system::error_code& e) { if (e != boost::asio::error::operation_aborted) { // Timer was not cancelled, take necessary action. } }
boost::asio::basic_deadline_timer::expires_from_now()
function cancels any pending asynchronous waits, and returns the number
of asynchronous waits that were cancelled. If it returns 0 then you were
too late and the wait handler has already been executed, or will soon
be executed. If it returns 1 then the wait handler was successfully cancelled.
boost::asio::error::operation_aborted.
Header: boost/asio/basic_deadline_timer.hpp
Convenience header: boost/asio.hpp
Start an asynchronous wait on the timer.
template< typename WaitHandler> void-or-deduced async_wait( WaitHandler handler);
This function may be used to initiate an asynchronous wait against the timer. It always returns immediately.
For each call to async_wait(), the supplied handler will be called
exactly once. The handler will be called when:
boost::asio::error::operation_aborted.
The handler to be called when the timer expires. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
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().
explicit basic_deadline_timer( boost::asio::io_service & io_service); » more...
Constructor to set a particular expiry time as an absolute time.
basic_deadline_timer( boost::asio::io_service & io_service, const time_type & expiry_time); » more...
Constructor to set a particular expiry time relative to now.
basic_deadline_timer( boost::asio::io_service & io_service, const duration_type & expiry_time); » more...
Constructor.
basic_deadline_timer( boost::asio::io_service & io_service);
This constructor creates a timer without setting an expiry time. The
expires_at()
or expires_from_now()
functions must be called to set an expiry time before the timer can be
waited on.
The io_service object that
the timer will use to dispatch handlers for any asynchronous operations
performed on the timer.
Constructor to set a particular expiry time as an absolute time.
basic_deadline_timer( boost::asio::io_service & io_service, const time_type & expiry_time);
This constructor creates a timer and sets the expiry time.
The io_service object that
the timer will use to dispatch handlers for any asynchronous operations
performed on the timer.
The expiry time to be used for the timer, expressed as an absolute time.
Constructor to set a particular expiry time relative to now.
basic_deadline_timer( boost::asio::io_service & io_service, const duration_type & expiry_time);
This constructor creates a timer and sets the expiry time.
The io_service object that
the timer will use to dispatch handlers for any asynchronous operations
performed on the timer.
The expiry time to be used for the timer, relative to now.
Cancel any asynchronous operations that are waiting on the timer.
std::size_t cancel(); » more... std::size_t cancel( boost::system::error_code & ec); » more...
Cancel any asynchronous operations that are waiting on the timer.
std::size_t cancel();
This function forces the completion of any pending asynchronous wait
operations against the timer. The handler for each cancelled operation
will be invoked with the boost::asio::error::operation_aborted
error code.
Cancelling the timer does not change the expiry time.
The number of asynchronous operations that were cancelled.
Thrown on failure.
If the timer has already expired when cancel() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancel any asynchronous operations that are waiting on the timer.
std::size_t cancel( boost::system::error_code & ec);
This function forces the completion of any pending asynchronous wait
operations against the timer. The handler for each cancelled operation
will be invoked with the boost::asio::error::operation_aborted
error code.
Cancelling the timer does not change the expiry time.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled.
If the timer has already expired when cancel() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancels one asynchronous operation that is waiting on the timer.
std::size_t cancel_one(); » more... std::size_t cancel_one( boost::system::error_code & ec); » more...
Cancels one asynchronous operation that is waiting on the timer.
std::size_t cancel_one();
This function forces the completion of one pending asynchronous wait
operation against the timer. Handlers are cancelled in FIFO order. The
handler for the cancelled operation will be invoked with the boost::asio::error::operation_aborted error code.
Cancelling the timer does not change the expiry time.
The number of asynchronous operations that were cancelled. That is, either 0 or 1.
Thrown on failure.
If the timer has already expired when cancel_one() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancels one asynchronous operation that is waiting on the timer.
std::size_t cancel_one( boost::system::error_code & ec);
This function forces the completion of one pending asynchronous wait
operation against the timer. Handlers are cancelled in FIFO order. The
handler for the cancelled operation will be invoked with the boost::asio::error::operation_aborted error code.
Cancelling the timer does not change the expiry time.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled. That is, either 0 or 1.
If the timer has already expired when cancel_one() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
typedef traits_type::duration_type duration_type;
Header: boost/asio/basic_deadline_timer.hpp
Convenience header: boost/asio.hpp
Get the timer's expiry time as an absolute time.
time_type expires_at() const; » more...
Set the timer's expiry time as an absolute time.
std::size_t expires_at( const time_type & expiry_time); » more... std::size_t expires_at( const time_type & expiry_time, boost::system::error_code & ec); » more...
Get the timer's expiry time as an absolute time.
time_type expires_at() const;
This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value.
Set the timer's expiry time as an absolute time.
std::size_t expires_at( const time_type & expiry_time);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
The number of asynchronous operations that were cancelled.
Thrown on failure.
If the timer has already expired when expires_at() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Set the timer's expiry time as an absolute time.
std::size_t expires_at( const time_type & expiry_time, boost::system::error_code & ec);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled.
If the timer has already expired when expires_at() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Get the timer's expiry time relative to now.
duration_type expires_from_now() const; » more...
Set the timer's expiry time relative to now.
std::size_t expires_from_now( const duration_type & expiry_time); » more... std::size_t expires_from_now( const duration_type & expiry_time, boost::system::error_code & ec); » more...
Get the timer's expiry time relative to now.
duration_type expires_from_now() const;
This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value.
Set the timer's expiry time relative to now.
std::size_t expires_from_now( const duration_type & expiry_time);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
The number of asynchronous operations that were cancelled.
Thrown on failure.
If the timer has already expired when expires_from_now() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Set the timer's expiry time relative to now.
std::size_t expires_from_now( const duration_type & expiry_time, boost::system::error_code & ec);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled.
If the timer has already expired when expires_from_now() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_deadline_timer.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef TimerService service_type;
Header: boost/asio/basic_deadline_timer.hpp
Convenience header: boost/asio.hpp
typedef traits_type::time_type time_type;
Header: boost/asio/basic_deadline_timer.hpp
Convenience header: boost/asio.hpp
typedef TimeTraits traits_type;
Header: boost/asio/basic_deadline_timer.hpp
Convenience header: boost/asio.hpp
Perform a blocking wait on the timer.
void wait(); » more... void wait( boost::system::error_code & ec); » more...
Perform a blocking wait on the timer.
void wait();
This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
Thrown on failure.
Perform a blocking wait on the timer.
void wait( boost::system::error_code & ec);
This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
Set to indicate what error occurred, if any.
Base class for all I/O objects.
template< typename IoObjectService> class basic_io_object
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Get the io_service associated with the object. |
|
Name |
Description |
|---|---|
|
Construct a basic_io_object. Move-construct a basic_io_object. |
|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Move-assign a basic_io_object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
All I/O objects are non-copyable. However, when using C++0x, certain I/O objects do support move construction and move assignment.
Header: boost/asio/basic_io_object.hpp
Convenience header: boost/asio.hpp
Construct a basic_io_object.
explicit basic_io_object( boost::asio::io_service & io_service); » more...
Move-construct a basic_io_object.
basic_io_object( basic_io_object && other); » more...
Construct a basic_io_object.
basic_io_object( boost::asio::io_service & io_service);
Performs:
get_service().construct(get_implementation());
Move-construct a basic_io_object.
basic_io_object( basic_io_object && other);
Performs:
get_service().move_construct( get_implementation(), other.get_implementation());
Available only for services that support movability,
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Get the service associated with the I/O object.
service_type & get_service();
Get the service associated with the I/O object.
const service_type & get_service() const;
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_io_object.hpp
Convenience header: boost/asio.hpp
Move-assign a basic_io_object.
basic_io_object & operator=( basic_io_object && other);
Performs:
get_service().move_assign(get_implementation(), other.get_service(), other.get_implementation());
Available only for services that support movability,
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
The type of the service that will be used to provide I/O operations.
typedef IoObjectService service_type;
Header: boost/asio/basic_io_object.hpp
Convenience header: boost/asio.hpp
Provides raw-oriented socket functionality.
template< typename Protocol, typename RawSocketService = raw_socket_service<Protocol>> class basic_raw_socket : public basic_socket< Protocol, RawSocketService >
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_raw_socket without opening it. Construct and open a basic_raw_socket. Construct a basic_raw_socket, opening it and binding it to the given local endpoint. Construct a basic_raw_socket on an existing native socket. Move-construct a basic_raw_socket from another. Move-construct a basic_raw_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_raw_socket from another. Move-assign a basic_raw_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive raw data with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send raw data to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_raw_socket
class template provides asynchronous and blocking raw-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket);
Inherited from basic_socket.
Assign an existing native socket to the socket.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Inherited from basic_socket.
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( const endpoint_type & peer_endpoint, ConnectHandler handler);
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.
The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.
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:
void handler( const boost::system::error_code& error // Result of operation );
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().
void connect_handler(const boost::system::error_code& error) { if (!error) { // Connect succeeded. } } ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.async_connect(endpoint, connect_handler);
Start an asynchronous receive on a connected socket.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, ReadHandler handler); » more... template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler); » more...
Start an asynchronous receive on a connected socket.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously receive data from the raw socket. The function call always returns immediately.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
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.
To receive into a single data buffer use the buffer function as follows:
socket.async_receive(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive on a connected socket.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler);
This function is used to asynchronously receive data from the raw socket. The function call always returns immediately.
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.
Flags specifying how the receive call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
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.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, ReadHandler handler); » more... template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, ReadHandler handler); » more...
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, ReadHandler handler);
This function is used to asynchronously receive raw data. The function call always returns immediately.
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.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
To receive into a single data buffer use the buffer function as follows:
socket.async_receive_from( boost::asio::buffer(data, size), 0, sender_endpoint, handler);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, ReadHandler handler);
This function is used to asynchronously receive raw data. The function call always returns immediately.
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.
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.
Flags specifying how the receive call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
Start an asynchronous send on a connected socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, WriteHandler handler); » more... template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler); » more...
Start an asynchronous send on a connected socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, WriteHandler handler);
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.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
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.
To send a single data buffer use the buffer function as follows:
socket.async_send(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous send on a connected socket.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
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.
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.
Flags specifying how the send call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
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-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, WriteHandler handler); » more... template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, WriteHandler handler); » more...
Start an asynchronous send.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, WriteHandler handler);
This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately.
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.
The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
To send a single data buffer use the buffer function as follows:
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);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous send.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, WriteHandler handler);
This function is used to asynchronously send raw data to the specified remote endpoint. The function call always returns immediately.
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.
Flags specifying how the send call is to be made.
The remote endpoint to which the data will be sent. Copies will be made of the endpoint as required.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const; » more... bool at_mark( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
A bool indicating whether the socket is at the out-of-band data mark.
Thrown on failure.
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark( boost::system::error_code & ec) const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
Set to indicate what error occurred, if any.
A bool indicating whether the socket is at the out-of-band data mark.
Determine the number of bytes available for reading.
std::size_t available() const; » more... std::size_t available( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available() const;
This function is used to determine the number of bytes that may be read without blocking.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Thrown on failure.
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available( boost::system::error_code & ec) const;
This function is used to determine the number of bytes that may be read without blocking.
Set to indicate what error occurred, if any.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Construct a basic_raw_socket without opening
it.
explicit basic_raw_socket( boost::asio::io_service & io_service); » more...
Construct and open a basic_raw_socket.
basic_raw_socket( boost::asio::io_service & io_service, const protocol_type & protocol); » more...
Construct a basic_raw_socket, opening it and
binding it to the given local endpoint.
basic_raw_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint); » more...
Construct a basic_raw_socket on an existing
native socket.
basic_raw_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket); » more...
Move-construct a basic_raw_socket from another.
basic_raw_socket( basic_raw_socket && other); » more...
Move-construct a basic_raw_socket from a socket
of another protocol type.
template< typename Protocol1, typename RawSocketService1> basic_raw_socket( basic_raw_socket< Protocol1, RawSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0); » more...
Construct a basic_raw_socket without opening
it.
basic_raw_socket( boost::asio::io_service & io_service);
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.
The io_service object that
the raw socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
Construct and open a basic_raw_socket.
basic_raw_socket( boost::asio::io_service & io_service, const protocol_type & protocol);
This constructor creates and opens a raw socket.
The io_service object that
the raw socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An object specifying protocol parameters to be used.
Thrown on failure.
Construct a basic_raw_socket, opening it
and binding it to the given local endpoint.
basic_raw_socket( boost::asio::io_service & io_service, const endpoint_type & 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.
The io_service object that
the raw socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An endpoint on the local machine to which the raw socket will be bound.
Thrown on failure.
Construct a basic_raw_socket on an existing
native socket.
basic_raw_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket);
This constructor creates a raw socket object to hold an existing native socket.
The io_service object that
the raw socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An object specifying protocol parameters to be used.
The new underlying socket implementation.
Thrown on failure.
Move-construct a basic_raw_socket from another.
basic_raw_socket( basic_raw_socket && other);
This constructor moves a raw socket from one object to another.
The other basic_raw_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_raw_socket(io_service&) constructor.
Move-construct a basic_raw_socket from a socket
of another protocol type.
template< typename Protocol1, typename RawSocketService1> basic_raw_socket( basic_raw_socket< Protocol1, RawSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
This constructor moves a raw socket from one object to another.
The other basic_raw_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_raw_socket(io_service&) constructor.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345));
Inherited from basic_socket.
Bind the socket to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); boost::system::error_code ec; socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345), ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the socket.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Close the socket.
void close();
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Inherited from basic_socket.
Close the socket.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.close(ec); if (ec) { // An error occurred. }
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_endpoint); » more... boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_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.
The remote endpoint to which the socket will be connected.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.connect(endpoint);
Inherited from basic_socket.
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec);
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.
The remote endpoint to which the socket will be connected.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); boost::system::error_code ec; socket.connect(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the socket.
void get_option( GettableSocketOption & option) const; » more... boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; socket.get_option(option); bool is_set = option.value();
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; boost::system::error_code ec; socket.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.value();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
void io_control( IoControlCommand & command); » more... boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; socket.io_control(command); std::size_t bytes_readable = command.get();
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Get the local endpoint of the socket.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the socket.
An object that represents the local endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec); if (ec) { // An error occurred. }
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from basic_socket.
Get a reference to the lowest layer.
lowest_layer_type & 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.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
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.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
A basic_socket is always the lowest
layer.
typedef basic_socket< Protocol, RawSocketService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
Inherited from basic_socket.
(Deprecated: Use native_handle().) Get the native socket representation.
native_type native();
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.
Inherited from basic_socket.
Get the native socket representation.
native_handle_type native_handle();
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.
The native representation of a socket.
typedef RawSocketService::native_handle_type native_handle_type;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
true if the underlying socket
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
(Deprecated: Use native_handle_type.) The native representation of a socket.
typedef RawSocketService::native_handle_type native_type;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking() const; » more...
Sets the non-blocking mode of the socket.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the socket.
bool non_blocking() const;
true if the socket's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
void non_blocking( bool mode);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket so that it will use the specified protocol.
An object specifying protocol parameters to be used.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4());
Inherited from basic_socket.
Open the socket using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::system::error_code ec; socket.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Move-assign a basic_raw_socket from another.
basic_raw_socket & operator=( basic_raw_socket && other); » more...
Move-assign a basic_raw_socket from a socket
of another protocol type.
template< typename Protocol1, typename RawSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_raw_socket >::type & operator=( basic_raw_socket< Protocol1, RawSocketService1 > && other); » more...
Move-assign a basic_raw_socket from another.
basic_raw_socket & operator=( basic_raw_socket && other);
This assignment operator moves a raw socket from one object to another.
The other basic_raw_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_raw_socket(io_service&) constructor.
Move-assign a basic_raw_socket from a socket
of another protocol type.
template< typename Protocol1, typename RawSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_raw_socket >::type & operator=( basic_raw_socket< Protocol1, RawSocketService1 > && other);
This assignment operator moves a raw socket from one object to another.
The other basic_raw_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_raw_socket(io_service&) constructor.
typedef Protocol protocol_type;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags); » more... template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers);
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.
One or more buffers into which the data will be received.
The number of bytes received.
Thrown on failure.
The receive operation can only be used with a connected socket. Use the receive_from function to receive data on an unconnected raw socket.
To receive into a single data buffer use the buffer function as follows:
socket.receive(boost::asio::buffer(data, size));
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags);
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.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
The number of bytes received.
Thrown on failure.
The receive operation can only be used with a connected socket. Use the receive_from function to receive data on an unconnected raw socket.
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
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.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
Set to indicate what error occurred, if any.
The number of bytes received.
The receive operation can only be used with a connected socket. Use the receive_from function to receive data on an unconnected raw socket.
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Receive raw data with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint); » more... template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags); » more... 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); » more...
Receive raw data with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint);
This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
An endpoint object that receives the endpoint of the remote sender of the data.
The number of bytes received.
Thrown on failure.
To receive into a single data buffer use the buffer function as follows:
boost::asio::ip::udp::endpoint sender_endpoint; socket.receive_from( boost::asio::buffer(data, size), sender_endpoint);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive raw data with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags);
This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
An endpoint object that receives the endpoint of the remote sender of the data.
Flags specifying how the receive call is to be made.
The number of bytes received.
Thrown on failure.
Receive raw data with the endpoint of the sender.
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);
This function is used to receive raw data. The function call will block until data has been received successfully or an error occurs.
One or more buffers into which the data will be received.
An endpoint object that receives the endpoint of the remote sender of the data.
Flags specifying how the receive call is to be made.
Set to indicate what error occurred, if any.
The number of bytes received.
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const; » more... endpoint_type remote_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const;
This function is used to obtain the remote endpoint of the socket.
An object that represents the remote endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the remote endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers);
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.
One ore more data buffers to be sent on the socket.
The number of bytes sent.
Thrown on failure.
The send operation can only be used with a connected socket. Use the send_to function to send data on an unconnected raw socket.
To send a single data buffer use the buffer function as follows:
socket.send(boost::asio::buffer(data, size));
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags);
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.
One ore more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
The number of bytes sent.
Thrown on failure.
The send operation can only be used with a connected socket. Use the send_to function to send data on an unconnected raw socket.
Send some data on a connected socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
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.
One or more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
Set to indicate what error occurred, if any.
The number of bytes sent.
The send operation can only be used with a connected socket. Use the send_to function to send data on an unconnected raw socket.
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
Send raw data to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination); » more... template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags); » more... 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); » more...
Send raw data to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination);
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.
One or more data buffers to be sent to the remote endpoint.
The remote endpoint to which the data will be sent.
The number of bytes sent.
Thrown on failure.
To send a single data buffer use the buffer function as follows:
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);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send raw data to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags);
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.
One or more data buffers to be sent to the remote endpoint.
The remote endpoint to which the data will be sent.
Flags specifying how the send call is to be made.
The number of bytes sent.
Thrown on failure.
Send raw data to the specified endpoint.
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);
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.
One or more data buffers to be sent to the remote endpoint.
The remote endpoint to which the data will be sent.
Flags specifying how the send call is to be made.
Set to indicate what error occurred, if any.
The number of bytes sent.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef RawSocketService service_type;
Header: boost/asio/basic_raw_socket.hpp
Convenience header: boost/asio.hpp
void set_option( const SettableSocketOption & option); » more... boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Thrown on failure.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Set to indicate what error occurred, if any.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); boost::system::error_code ec; socket.set_option(option, ec); if (ec) { // An error occurred. }
Disable sends or receives on the socket.
void shutdown( shutdown_type what); » more... boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Disable sends or receives on the socket.
void shutdown( shutdown_type what);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Thrown on failure.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
Inherited from basic_socket.
Disable sends or receives on the socket.
boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Set to indicate what error occurred, if any.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Provides sequenced packet socket functionality.
template< typename Protocol, typename SeqPacketSocketService = seq_packet_socket_service<Protocol>> class basic_seq_packet_socket : public basic_socket< Protocol, SeqPacketSocketService >
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_seq_packet_socket without opening it. Construct and open a basic_seq_packet_socket. Construct a basic_seq_packet_socket, opening it and binding it to the given local endpoint. Construct a basic_seq_packet_socket on an existing native socket. Move-construct a basic_seq_packet_socket from another. Move-construct a basic_seq_packet_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_seq_packet_socket from another. Move-assign a basic_seq_packet_socket from a socket of another protocol type. |
|
|
Receive some data on the socket. Receive some data on a connected socket. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_seq_packet_socket class template
provides asynchronous and blocking sequenced packet socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket);
Inherited from basic_socket.
Assign an existing native socket to the socket.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Inherited from basic_socket.
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( const endpoint_type & peer_endpoint, ConnectHandler handler);
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.
The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.
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:
void handler( const boost::system::error_code& error // Result of operation );
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().
void connect_handler(const boost::system::error_code& error) { if (!error) { // Connect succeeded. } } ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.async_connect(endpoint, connect_handler);
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags & out_flags, ReadHandler handler); » more... template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, ReadHandler handler); » more...
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags & out_flags, ReadHandler handler);
This function is used to asynchronously receive data from the sequenced packet socket. The function call always returns immediately.
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.
Once the asynchronous operation completes, contains flags associated
with the received data. For example, if the socket_base::message_end_of_record
bit is set then the received data marks the end of a record. The
caller must guarantee that the referenced variable remains valid
until the handler is called.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
To receive into a single data buffer use the buffer function as follows:
socket.async_receive(boost::asio::buffer(data, size), out_flags, handler);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, ReadHandler handler);
This function is used to asynchronously receive data from the sequenced data socket. The function call always returns immediately.
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.
Flags specifying how the receive call is to be made.
Once the asynchronous operation completes, contains flags associated
with the received data. For example, if the socket_base::message_end_of_record
bit is set then the received data marks the end of a record. The
caller must guarantee that the referenced variable remains valid
until the handler is called.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
To receive into a single data buffer use the buffer function as follows:
socket.async_receive( boost::asio::buffer(data, size), 0, out_flags, handler);
See the 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 ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
This function is used to asynchronously send data on the sequenced packet socket. The function call always returns immediately.
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.
Flags specifying how the send call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
To send a single data buffer use the buffer function as follows:
socket.async_send(boost::asio::buffer(data, size), 0, handler);
See the buffer
documentation for information on sending multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const; » more... bool at_mark( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
A bool indicating whether the socket is at the out-of-band data mark.
Thrown on failure.
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark( boost::system::error_code & ec) const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
Set to indicate what error occurred, if any.
A bool indicating whether the socket is at the out-of-band data mark.
Determine the number of bytes available for reading.
std::size_t available() const; » more... std::size_t available( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available() const;
This function is used to determine the number of bytes that may be read without blocking.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Thrown on failure.
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available( boost::system::error_code & ec) const;
This function is used to determine the number of bytes that may be read without blocking.
Set to indicate what error occurred, if any.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Construct a basic_seq_packet_socket without
opening it.
explicit basic_seq_packet_socket( boost::asio::io_service & io_service); » more...
Construct and open a basic_seq_packet_socket.
basic_seq_packet_socket( boost::asio::io_service & io_service, const protocol_type & protocol); » more...
Construct a basic_seq_packet_socket, opening
it and binding it to the given local endpoint.
basic_seq_packet_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint); » more...
Construct a basic_seq_packet_socket on an
existing native socket.
basic_seq_packet_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket); » more...
Move-construct a basic_seq_packet_socket from another.
basic_seq_packet_socket( basic_seq_packet_socket && other); » more...
Move-construct a basic_seq_packet_socket from a
socket of another protocol type.
template< typename Protocol1, typename SeqPacketSocketService1> basic_seq_packet_socket( basic_seq_packet_socket< Protocol1, SeqPacketSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0); » more...
Construct a basic_seq_packet_socket without
opening it.
basic_seq_packet_socket( boost::asio::io_service & io_service);
This constructor creates a sequenced packet socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.
The io_service object that
the sequenced packet socket will use to dispatch handlers for any
asynchronous operations performed on the socket.
Construct and open a basic_seq_packet_socket.
basic_seq_packet_socket( boost::asio::io_service & io_service, const protocol_type & protocol);
This constructor creates and opens a sequenced_packet socket. The socket needs to be connected or accepted before data can be sent or received on it.
The io_service object that
the sequenced packet socket will use to dispatch handlers for any
asynchronous operations performed on the socket.
An object specifying protocol parameters to be used.
Thrown on failure.
Construct a basic_seq_packet_socket, opening
it and binding it to the given local endpoint.
basic_seq_packet_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint);
This constructor creates a sequenced packet 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.
The io_service object that
the sequenced packet socket will use to dispatch handlers for any
asynchronous operations performed on the socket.
An endpoint on the local machine to which the sequenced packet socket will be bound.
Thrown on failure.
Construct a basic_seq_packet_socket on an
existing native socket.
basic_seq_packet_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket);
This constructor creates a sequenced packet socket object to hold an existing native socket.
The io_service object that
the sequenced packet socket will use to dispatch handlers for any
asynchronous operations performed on the socket.
An object specifying protocol parameters to be used.
The new underlying socket implementation.
Thrown on failure.
Move-construct a basic_seq_packet_socket from
another.
basic_seq_packet_socket( basic_seq_packet_socket && other);
This constructor moves a sequenced packet socket from one object to another.
The other basic_seq_packet_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_seq_packet_socket(io_service&) constructor.
Move-construct a basic_seq_packet_socket from
a socket of another protocol type.
template< typename Protocol1, typename SeqPacketSocketService1> basic_seq_packet_socket( basic_seq_packet_socket< Protocol1, SeqPacketSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
This constructor moves a sequenced packet socket from one object to another.
The other basic_seq_packet_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_seq_packet_socket(io_service&) constructor.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345));
Inherited from basic_socket.
Bind the socket to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); boost::system::error_code ec; socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345), ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the socket.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Close the socket.
void close();
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Inherited from basic_socket.
Close the socket.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.close(ec); if (ec) { // An error occurred. }
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_endpoint); » more... boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_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.
The remote endpoint to which the socket will be connected.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.connect(endpoint);
Inherited from basic_socket.
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec);
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.
The remote endpoint to which the socket will be connected.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); boost::system::error_code ec; socket.connect(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the socket.
void get_option( GettableSocketOption & option) const; » more... boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; socket.get_option(option); bool is_set = option.value();
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; boost::system::error_code ec; socket.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.value();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
void io_control( IoControlCommand & command); » more... boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; socket.io_control(command); std::size_t bytes_readable = command.get();
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Get the local endpoint of the socket.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the socket.
An object that represents the local endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec); if (ec) { // An error occurred. }
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from basic_socket.
Get a reference to the lowest layer.
lowest_layer_type & 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.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
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.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
A basic_socket is always the lowest
layer.
typedef basic_socket< Protocol, SeqPacketSocketService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
Inherited from basic_socket.
(Deprecated: Use native_handle().) Get the native socket representation.
native_type native();
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.
Inherited from basic_socket.
Get the native socket representation.
native_handle_type native_handle();
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.
The native representation of a socket.
typedef SeqPacketSocketService::native_handle_type native_handle_type;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
true if the underlying socket
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
(Deprecated: Use native_handle_type.) The native representation of a socket.
typedef SeqPacketSocketService::native_handle_type native_type;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking() const; » more...
Sets the non-blocking mode of the socket.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the socket.
bool non_blocking() const;
true if the socket's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
void non_blocking( bool mode);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket so that it will use the specified protocol.
An object specifying protocol parameters to be used.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4());
Inherited from basic_socket.
Open the socket using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::system::error_code ec; socket.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Move-assign a basic_seq_packet_socket from another.
basic_seq_packet_socket & operator=( basic_seq_packet_socket && other); » more...
Move-assign a basic_seq_packet_socket from a
socket of another protocol type.
template< typename Protocol1, typename SeqPacketSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_seq_packet_socket >::type & operator=( basic_seq_packet_socket< Protocol1, SeqPacketSocketService1 > && other); » more...
Move-assign a basic_seq_packet_socket from
another.
basic_seq_packet_socket & operator=( basic_seq_packet_socket && other);
This assignment operator moves a sequenced packet socket from one object to another.
The other basic_seq_packet_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_seq_packet_socket(io_service&) constructor.
Move-assign a basic_seq_packet_socket from
a socket of another protocol type.
template< typename Protocol1, typename SeqPacketSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_seq_packet_socket >::type & operator=( basic_seq_packet_socket< Protocol1, SeqPacketSocketService1 > && other);
This assignment operator moves a sequenced packet socket from one object to another.
The other basic_seq_packet_socket
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_seq_packet_socket(io_service&) constructor.
typedef Protocol protocol_type;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Receive some data on the socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags & out_flags); » more... template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags); » more...
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, boost::system::error_code & ec); » more...
Receive some data on the socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags & out_flags);
This function is used to receive data on the sequenced packet socket. The function call will block until data has been received successfully, or until an error occurs.
One or more buffers into which the data will be received.
After the receive call completes, contains flags associated with
the received data. For example, if the socket_base::message_end_of_record
bit is set then the received data marks the end of a record.
The number of bytes received.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
To receive into a single data buffer use the buffer function as follows:
socket.receive(boost::asio::buffer(data, size), out_flags);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive some data on the socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags);
This function is used to receive data on the sequenced packet socket. The function call will block until data has been received successfully, or until an error occurs.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
After the receive call completes, contains flags associated with
the received data. For example, if the socket_base::message_end_of_record
bit is set then the received data marks the end of a record.
The number of bytes received.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The receive operation may not receive all of the requested number of
bytes. Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To receive into a single data buffer use the buffer function as follows:
socket.receive(boost::asio::buffer(data, size), 0, out_flags);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, boost::system::error_code & ec);
This function is used to receive data on the sequenced packet socket. The function call will block until data has been received successfully, or until an error occurs.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
After the receive call completes, contains flags associated with
the received data. For example, if the socket_base::message_end_of_record
bit is set then the received data marks the end of a record.
Set to indicate what error occurred, if any.
The number of bytes received. Returns 0 if an error occurred.
The receive operation may not receive all of the requested number of
bytes. Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const; » more... endpoint_type remote_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const;
This function is used to obtain the remote endpoint of the socket.
An object that represents the remote endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the remote endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Send some data on the socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags);
This function is used to send data on the sequenced packet socket. The function call will block until the data has been sent successfully, or an until error occurs.
One or more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
The number of bytes sent.
Thrown on failure.
To send a single data buffer use the buffer function as follows:
socket.send(boost::asio::buffer(data, size), 0);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send some data on the socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
This function is used to send data on the sequenced packet socket. The function call will block the data has been sent successfully, or an until error occurs.
One or more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
Set to indicate what error occurred, if any.
The number of bytes sent. Returns 0 if an error occurred.
The send operation may not transmit all of the data to the peer. Consider
using the write
function if you need to ensure that all data is written before the blocking
operation completes.
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef SeqPacketSocketService service_type;
Header: boost/asio/basic_seq_packet_socket.hpp
Convenience header: boost/asio.hpp
void set_option( const SettableSocketOption & option); » more... boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Thrown on failure.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Set to indicate what error occurred, if any.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); boost::system::error_code ec; socket.set_option(option, ec); if (ec) { // An error occurred. }
Disable sends or receives on the socket.
void shutdown( shutdown_type what); » more... boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Disable sends or receives on the socket.
void shutdown( shutdown_type what);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Thrown on failure.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
Inherited from basic_socket.
Disable sends or receives on the socket.
boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Set to indicate what error occurred, if any.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Provides serial port functionality.
template< typename SerialPortService = serial_port_service> class basic_serial_port : public basic_io_object< SerialPortService >, public serial_port_base
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_serial_port is always the lowest layer. |
|
|
The native representation of a serial port. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a serial port. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native serial port to the serial port. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_serial_port without opening it. Construct and open a basic_serial_port. Construct a basic_serial_port on an existing native serial port. Move-construct a basic_serial_port from another. |
|
|
Cancel all asynchronous operations associated with the serial port. |
|
|
Close the serial port. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the serial port. |
|
|
Determine whether the serial port is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native serial port representation. |
|
|
Get the native serial port representation. |
|
|
Open the serial port using the specified device name. |
|
|
Move-assign a basic_serial_port from another. |
|
|
Read some data from the serial port. |
|
|
Send a break sequence to the serial port. |
|
|
Set an option on the serial port. |
|
|
Write some data to the serial port. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_serial_port class template
provides functionality that is common to all serial ports.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_serial_port.hpp
Convenience header: boost/asio.hpp
Assign an existing native serial port to the serial port.
void assign( const native_handle_type & native_serial_port); » more... boost::system::error_code assign( const native_handle_type & native_serial_port, boost::system::error_code & ec); » more...
Assign an existing native serial port to the serial port.
void assign( const native_handle_type & native_serial_port);
Assign an existing native serial port to the serial port.
boost::system::error_code assign( const native_handle_type & native_serial_port, boost::system::error_code & ec);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read data from the serial port. The function call always returns immediately.
One or more buffers into which the data will be read. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. );
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().
The read operation may not read all of the requested number of bytes. Consider
using the async_read function if you need
to ensure that the requested amount of data is read before the asynchronous
operation completes.
To read into a single data buffer use the buffer function as follows:
serial_port.async_read_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write data to the serial port. The function call always returns immediately.
One or more data buffers to be written to the serial port. 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. );
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().
The write operation may not transmit all of the data to the peer. Consider
using the async_write function if you need
to ensure that all data is written before the asynchronous operation completes.
To write a single data buffer use the buffer function as follows:
serial_port.async_write_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Construct a basic_serial_port without opening
it.
explicit basic_serial_port( boost::asio::io_service & io_service); » more...
Construct and open a basic_serial_port.
explicit basic_serial_port( boost::asio::io_service & io_service, const char * device); » more... explicit basic_serial_port( boost::asio::io_service & io_service, const std::string & device); » more...
Construct a basic_serial_port on an existing
native serial port.
basic_serial_port( boost::asio::io_service & io_service, const native_handle_type & native_serial_port); » more...
Move-construct a basic_serial_port from another.
basic_serial_port( basic_serial_port && other); » more...
Construct a basic_serial_port without opening
it.
basic_serial_port( boost::asio::io_service & io_service);
This constructor creates a serial port without opening it.
The io_service object that
the serial port will use to dispatch handlers for any asynchronous
operations performed on the port.
Construct and open a basic_serial_port.
basic_serial_port( boost::asio::io_service & io_service, const char * device);
This constructor creates and opens a serial port for the specified device name.
The io_service object that
the serial port will use to dispatch handlers for any asynchronous
operations performed on the port.
The platform-specific device name for this serial port.
Construct and open a basic_serial_port.
basic_serial_port( boost::asio::io_service & io_service, const std::string & device);
This constructor creates and opens a serial port for the specified device name.
The io_service object that
the serial port will use to dispatch handlers for any asynchronous
operations performed on the port.
The platform-specific device name for this serial port.
Construct a basic_serial_port on an existing
native serial port.
basic_serial_port( boost::asio::io_service & io_service, const native_handle_type & native_serial_port);
This constructor creates a serial port object to hold an existing native serial port.
The io_service object that
the serial port will use to dispatch handlers for any asynchronous
operations performed on the port.
A native serial port.
Thrown on failure.
Move-construct a basic_serial_port from another.
basic_serial_port( basic_serial_port && other);
This constructor moves a serial port from one object to another.
The other basic_serial_port object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_serial_port(io_service&) constructor.
Cancel all asynchronous operations associated with the serial port.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Cancel all asynchronous operations associated with the serial port.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Cancel all asynchronous operations associated with the serial port.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the serial port.
void close();
This function is used to close the serial port. Any asynchronous read
or write operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure.
Close the serial port.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the serial port. Any asynchronous read
or write operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the serial port.
template< typename GettableSerialPortOption> void get_option( GettableSerialPortOption & option); » more... template< typename GettableSerialPortOption> boost::system::error_code get_option( GettableSerialPortOption & option, boost::system::error_code & ec); » more...
Get an option from the serial port.
template< typename GettableSerialPortOption> void get_option( GettableSerialPortOption & option);
This function is used to get the current value of an option on the serial port.
The option value to be obtained from the serial port.
Thrown on failure.
Get an option from the serial port.
template< typename GettableSerialPortOption> boost::system::error_code get_option( GettableSerialPortOption & option, boost::system::error_code & ec);
This function is used to get the current value of an option on the serial port.
The option value to be obtained from the serial port.
Set to indicate what error occurred, if any.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_serial_port.hpp
Convenience header: boost/asio.hpp
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a basic_serial_port cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a basic_serial_port cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
A basic_serial_port is always the
lowest layer.
typedef basic_serial_port< SerialPortService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_serial_port is always the lowest layer. |
|
|
The native representation of a serial port. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a serial port. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native serial port to the serial port. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_serial_port without opening it. Construct and open a basic_serial_port. Construct a basic_serial_port on an existing native serial port. Move-construct a basic_serial_port from another. |
|
|
Cancel all asynchronous operations associated with the serial port. |
|
|
Close the serial port. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the serial port. |
|
|
Determine whether the serial port is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native serial port representation. |
|
|
Get the native serial port representation. |
|
|
Open the serial port using the specified device name. |
|
|
Move-assign a basic_serial_port from another. |
|
|
Read some data from the serial port. |
|
|
Send a break sequence to the serial port. |
|
|
Set an option on the serial port. |
|
|
Write some data to the serial port. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_serial_port class template
provides functionality that is common to all serial ports.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_serial_port.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle().) Get the native serial port representation.
native_type native();
This function may be used to obtain the underlying representation of the serial port. This is intended to allow access to native serial port functionality that is not otherwise provided.
Get the native serial port representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the serial port. This is intended to allow access to native serial port functionality that is not otherwise provided.
The native representation of a serial port.
typedef SerialPortService::native_handle_type native_handle_type;
Header: boost/asio/basic_serial_port.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native representation of a serial port.
typedef SerialPortService::native_handle_type native_type;
Header: boost/asio/basic_serial_port.hpp
Convenience header: boost/asio.hpp
Open the serial port using the specified device name.
void open( const std::string & device); » more... boost::system::error_code open( const std::string & device, boost::system::error_code & ec); » more...
Open the serial port using the specified device name.
void open( const std::string & device);
This function opens the serial port for the specified device name.
The platform-specific device name.
Thrown on failure.
Open the serial port using the specified device name.
boost::system::error_code open( const std::string & device, boost::system::error_code & ec);
This function opens the serial port using the given platform-specific device name.
The platform-specific device name.
Set the indicate what error occurred, if any.
Move-assign a basic_serial_port from another.
basic_serial_port & operator=( basic_serial_port && other);
This assignment operator moves a serial port from one object to another.
The other basic_serial_port object
from which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_serial_port(io_service&) constructor.
Read some data from the serial port.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the serial port.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
This function is used to read data from the serial port. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
The number of bytes read.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To read into a single data buffer use the buffer function as follows:
serial_port.read_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Read some data from the serial port.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read data from the serial port. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes read. Returns 0 if an error occurred.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Send a break sequence to the serial port.
void send_break(); » more... boost::system::error_code send_break( boost::system::error_code & ec); » more...
Send a break sequence to the serial port.
void send_break();
This function causes a break sequence of platform-specific duration to be sent out the serial port.
Thrown on failure.
Send a break sequence to the serial port.
boost::system::error_code send_break( boost::system::error_code & ec);
This function causes a break sequence of platform-specific duration to be sent out the serial port.
Set to indicate what error occurred, if any.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef SerialPortService service_type;
Header: boost/asio/basic_serial_port.hpp
Convenience header: boost/asio.hpp
Set an option on the serial port.
template< typename SettableSerialPortOption> void set_option( const SettableSerialPortOption & option); » more... template< typename SettableSerialPortOption> boost::system::error_code set_option( const SettableSerialPortOption & option, boost::system::error_code & ec); » more...
Set an option on the serial port.
template< typename SettableSerialPortOption> void set_option( const SettableSerialPortOption & option);
This function is used to set an option on the serial port.
The option value to be set on the serial port.
Thrown on failure.
Set an option on the serial port.
template< typename SettableSerialPortOption> boost::system::error_code set_option( const SettableSerialPortOption & option, boost::system::error_code & ec);
This function is used to set an option on the serial port.
The option value to be set on the serial port.
Set to indicate what error occurred, if any.
Write some data to the serial port.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write some data to the serial port.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
This function is used to write data to the serial port. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the serial port.
The number of bytes written.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
To write a single data buffer use the buffer function as follows:
serial_port.write_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Write some data to the serial port.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write data to the serial port. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the serial port.
Set to indicate what error occurred, if any.
The number of bytes written. Returns 0 if an error occurred.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
Provides signal functionality.
template< typename SignalSetService = signal_set_service> class basic_signal_set : public basic_io_object< SignalSetService >
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Add a signal to a signal_set. |
|
|
Start an asynchronous operation to wait for a signal to be delivered. |
|
|
Construct a signal set without adding any signals. Construct a signal set and add one signal. Construct a signal set and add two signals. Construct a signal set and add three signals. |
|
|
Cancel all operations associated with the signal set. |
|
|
Remove all signals from a signal_set. |
|
|
Get the io_service associated with the object. |
|
|
Remove a signal from a signal_set. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_signal_set
class template provides the ability to perform an asynchronous wait for one
or more signals to occur.
Most applications will use the signal_set typedef.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing an asynchronous wait:
void handler( const boost::system::error_code& error, int signal_number) { if (!error) { // A signal occurred. } } ... // Construct a signal set registered for process termination. boost::asio::signal_set signals(io_service, SIGINT, SIGTERM); // Start an asynchronous wait for one of the signals to occur. signals.async_wait(handler);
If a signal is registered with a signal_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async_wait operation on that signal_set will dequeue the notification. If multiple notifications are queued, subsequent async_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.
If a signal number is removed from a signal_set (using the remove or erase
member functions) then any queued notifications for that signal are discarded.
The same signal number may be registered with different signal_set objects. When the signal occurs, one handler is called for each signal_set object.
Note that multiple registration only works for signals that are registered
using Asio. The application must not also register a signal handler using
functions such as signal() or sigaction().
POSIX allows signals to be blocked using functions such as sigprocmask()
and pthread_sigmask().
For signals to be delivered, programs must ensure that any signals registered
using signal_set objects are unblocked in at least one thread.
Header: boost/asio/basic_signal_set.hpp
Convenience header: boost/asio.hpp
void add( int signal_number); » more... boost::system::error_code add( int signal_number, boost::system::error_code & ec); » more...
Add a signal to a signal_set.
void add( int signal_number);
This function adds the specified signal to the set. It has no effect if the signal is already in the set.
The signal to be added to the set.
Thrown on failure.
Add a signal to a signal_set.
boost::system::error_code add( int signal_number, boost::system::error_code & ec);
This function adds the specified signal to the set. It has no effect if the signal is already in the set.
The signal to be added to the set.
Set to indicate what error occurred, if any.
Start an asynchronous operation to wait for a signal to be delivered.
template< typename SignalHandler> void-or-deduced async_wait( SignalHandler handler);
This function may be used to initiate an asynchronous wait against the signal set. It always returns immediately.
For each call to async_wait(), the supplied handler will be called
exactly once. The handler will be called when:
boost::asio::error::operation_aborted.
The handler to be called when the signal occurs. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. int signal_number // Indicates which signal occurred. );
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().
Construct a signal set without adding any signals.
explicit basic_signal_set( boost::asio::io_service & io_service); » more...
Construct a signal set and add one signal.
basic_signal_set( boost::asio::io_service & io_service, int signal_number_1); » more...
Construct a signal set and add two signals.
basic_signal_set( boost::asio::io_service & io_service, int signal_number_1, int signal_number_2); » more...
Construct a signal set and add three signals.
basic_signal_set( boost::asio::io_service & io_service, int signal_number_1, int signal_number_2, int signal_number_3); » more...
Construct a signal set without adding any signals.
basic_signal_set( boost::asio::io_service & io_service);
This constructor creates a signal set without registering for any signals.
The io_service object that
the signal set will use to dispatch handlers for any asynchronous
operations performed on the set.
Construct a signal set and add one signal.
basic_signal_set( boost::asio::io_service & io_service, int signal_number_1);
This constructor creates a signal set and registers for one signal.
The io_service object that
the signal set will use to dispatch handlers for any asynchronous
operations performed on the set.
The signal number to be added.
This constructor is equivalent to performing:
boost::asio::signal_set signals(io_service); signals.add(signal_number_1);
Construct a signal set and add two signals.
basic_signal_set( boost::asio::io_service & io_service, int signal_number_1, int signal_number_2);
This constructor creates a signal set and registers for two signals.
The io_service object that
the signal set will use to dispatch handlers for any asynchronous
operations performed on the set.
The first signal number to be added.
The second signal number to be added.
This constructor is equivalent to performing:
boost::asio::signal_set signals(io_service); signals.add(signal_number_1); signals.add(signal_number_2);
Construct a signal set and add three signals.
basic_signal_set( boost::asio::io_service & io_service, int signal_number_1, int signal_number_2, int signal_number_3);
This constructor creates a signal set and registers for three signals.
The io_service object that
the signal set will use to dispatch handlers for any asynchronous
operations performed on the set.
The first signal number to be added.
The second signal number to be added.
The third signal number to be added.
This constructor is equivalent to performing:
boost::asio::signal_set signals(io_service); signals.add(signal_number_1); signals.add(signal_number_2); signals.add(signal_number_3);
Cancel all operations associated with the signal set.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Cancel all operations associated with the signal set.
void cancel();
This function forces the completion of any pending asynchronous wait
operations against the signal set. The handler for each cancelled operation
will be invoked with the boost::asio::error::operation_aborted
error code.
Cancellation does not alter the set of registered signals.
Thrown on failure.
If a registered signal occurred before cancel() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancel all operations associated with the signal set.
boost::system::error_code cancel( boost::system::error_code & ec);
This function forces the completion of any pending asynchronous wait
operations against the signal set. The handler for each cancelled operation
will be invoked with the boost::asio::error::operation_aborted
error code.
Cancellation does not alter the set of registered signals.
Set to indicate what error occurred, if any.
If a registered signal occurred before cancel() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Remove all signals from a signal_set.
void clear(); » more... boost::system::error_code clear( boost::system::error_code & ec); » more...
Remove all signals from a signal_set.
void clear();
This function removes all signals from the set. It has no effect if the set is already empty.
Thrown on failure.
Removes all queued notifications.
Remove all signals from a signal_set.
boost::system::error_code clear( boost::system::error_code & ec);
This function removes all signals from the set. It has no effect if the set is already empty.
Set to indicate what error occurred, if any.
Removes all queued notifications.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_signal_set.hpp
Convenience header: boost/asio.hpp
Remove a signal from a signal_set.
void remove( int signal_number); » more... boost::system::error_code remove( int signal_number, boost::system::error_code & ec); » more...
Remove a signal from a signal_set.
void remove( int signal_number);
This function removes the specified signal from the set. It has no effect if the signal is not in the set.
The signal to be removed from the set.
Thrown on failure.
Removes any notifications that have been queued for the specified signal number.
Remove a signal from a signal_set.
boost::system::error_code remove( int signal_number, boost::system::error_code & ec);
This function removes the specified signal from the set. It has no effect if the signal is not in the set.
The signal to be removed from the set.
Set to indicate what error occurred, if any.
Removes any notifications that have been queued for the specified signal number.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef SignalSetService service_type;
Header: boost/asio/basic_signal_set.hpp
Convenience header: boost/asio.hpp
Provides socket functionality.
template< typename Protocol, typename SocketService> class basic_socket : public basic_io_object< SocketService >, public socket_base
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec); » more...
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket);
Assign an existing native socket to the socket.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( const endpoint_type & peer_endpoint, ConnectHandler handler);
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.
The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.
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:
void handler( const boost::system::error_code& error // Result of operation );
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().
void connect_handler(const boost::system::error_code& error) { if (!error) { // Connect succeeded. } } ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.async_connect(endpoint, connect_handler);
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const; » more... bool at_mark( boost::system::error_code & ec) const; » more...
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
A bool indicating whether the socket is at the out-of-band data mark.
Thrown on failure.
Determine whether the socket is at the out-of-band data mark.
bool at_mark( boost::system::error_code & ec) const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
Set to indicate what error occurred, if any.
A bool indicating whether the socket is at the out-of-band data mark.
Determine the number of bytes available for reading.
std::size_t available() const; » more... std::size_t available( boost::system::error_code & ec) const; » more...
Determine the number of bytes available for reading.
std::size_t available() const;
This function is used to determine the number of bytes that may be read without blocking.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Thrown on failure.
Determine the number of bytes available for reading.
std::size_t available( boost::system::error_code & ec) const;
This function is used to determine the number of bytes that may be read without blocking.
Set to indicate what error occurred, if any.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Construct a basic_socket without opening it.
explicit basic_socket( boost::asio::io_service & io_service); » more...
Construct and open a basic_socket.
basic_socket( boost::asio::io_service & io_service, const protocol_type & protocol); » more...
Construct a basic_socket, opening it and binding
it to the given local endpoint.
basic_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint); » more...
Construct a basic_socket on an existing native
socket.
basic_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket); » more...
Move-construct a basic_socket from another.
basic_socket( basic_socket && other); » more...
Move-construct a basic_socket from a socket of
another protocol type.
template< typename Protocol1, typename SocketService1> basic_socket( basic_socket< Protocol1, SocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0); » more...
Construct a basic_socket without opening
it.
basic_socket( boost::asio::io_service & io_service);
This constructor creates a socket without opening it.
The io_service object that
the socket will use to dispatch handlers for any asynchronous operations
performed on the socket.
Construct and open a basic_socket.
basic_socket( boost::asio::io_service & io_service, const protocol_type & protocol);
This constructor creates and opens a socket.
The io_service object that
the socket will use to dispatch handlers for any asynchronous operations
performed on the socket.
An object specifying protocol parameters to be used.
Thrown on failure.
Construct a basic_socket, opening it and
binding it to the given local endpoint.
basic_socket( boost::asio::io_service & io_service, const endpoint_type & 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.
The io_service object that
the socket will use to dispatch handlers for any asynchronous operations
performed on the socket.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
Construct a basic_socket on an existing
native socket.
basic_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket);
This constructor creates a socket object to hold an existing native socket.
The io_service object that
the socket will use to dispatch handlers for any asynchronous operations
performed on the socket.
An object specifying protocol parameters to be used.
A native socket.
Thrown on failure.
Move-construct a basic_socket from another.
basic_socket( basic_socket && other);
This constructor moves a socket from one object to another.
The other basic_socket object from
which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket(io_service&) constructor.
Move-construct a basic_socket from a socket of
another protocol type.
template< typename Protocol1, typename SocketService1> basic_socket( basic_socket< Protocol1, SocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
This constructor moves a socket from one object to another.
The other basic_socket object from
which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket(io_service&) constructor.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345));
Bind the socket to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); boost::system::error_code ec; socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345), ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the socket.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Cancel all asynchronous operations associated with the socket.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the socket.
void close();
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Close the socket.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.close(ec); if (ec) { // An error occurred. }
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_endpoint); » more... boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_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.
The remote endpoint to which the socket will be connected.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.connect(endpoint);
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec);
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.
The remote endpoint to which the socket will be connected.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); boost::system::error_code ec; socket.connect(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const; » more... template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const; » more...
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; socket.get_option(option); bool is_set = option.value();
Get an option from the socket.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; boost::system::error_code ec; socket.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.value();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command); » more... template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; socket.io_control(command); std::size_t bytes_readable = command.get();
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Get the local endpoint of the socket.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Get the local endpoint of the socket.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the socket.
An object that represents the local endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
Get the local endpoint of the socket.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec); if (ec) { // An error occurred. }
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & 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.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
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.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
A basic_socket is always the lowest
layer.
typedef basic_socket< Protocol, SocketService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
(Deprecated: Use native_handle().) Get the native socket representation.
native_type native();
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.
Get the native socket representation.
native_handle_type native_handle();
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.
The native representation of a socket.
typedef SocketService::native_handle_type native_handle_type;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
true if the underlying socket
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
(Deprecated: Use native_handle_type.) The native representation of a socket.
typedef SocketService::native_handle_type native_type;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking() const; » more...
Sets the non-blocking mode of the socket.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the socket.
bool non_blocking() const;
true if the socket's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Sets the non-blocking mode of the socket.
void non_blocking( bool mode);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket so that it will use the specified protocol.
An object specifying protocol parameters to be used.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4());
Open the socket using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::system::error_code ec; socket.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Move-assign a basic_socket from another.
basic_socket & operator=( basic_socket && other); » more...
Move-assign a basic_socket from a socket of
another protocol type.
template< typename Protocol1, typename SocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_socket >::type & operator=( basic_socket< Protocol1, SocketService1 > && other); » more...
Move-assign a basic_socket from another.
basic_socket & operator=( basic_socket && other);
This assignment operator moves a socket from one object to another.
The other basic_socket object from
which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket(io_service&) constructor.
Move-assign a basic_socket from a socket of
another protocol type.
template< typename Protocol1, typename SocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_socket >::type & operator=( basic_socket< Protocol1, SocketService1 > && other);
This assignment operator moves a socket from one object to another.
The other basic_socket object from
which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket(io_service&) constructor.
typedef Protocol protocol_type;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const; » more... endpoint_type remote_endpoint( boost::system::error_code & ec) const; » more...
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const;
This function is used to obtain the remote endpoint of the socket.
An object that represents the remote endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
Get the remote endpoint of the socket.
endpoint_type remote_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the remote endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef SocketService service_type;
Header: boost/asio/basic_socket.hpp
Convenience header: boost/asio.hpp
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option); » more... template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Set an option on the socket.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Thrown on failure.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Set an option on the socket.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Set to indicate what error occurred, if any.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); boost::system::error_code ec; socket.set_option(option, ec); if (ec) { // An error occurred. }
Disable sends or receives on the socket.
void shutdown( shutdown_type what); » more... boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec); » more...
Disable sends or receives on the socket.
void shutdown( shutdown_type what);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Thrown on failure.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
Disable sends or receives on the socket.
boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Set to indicate what error occurred, if any.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Provides the ability to accept new connections.
template< typename Protocol, typename SocketAcceptorService = socket_acceptor_service<Protocol>> class basic_socket_acceptor : public basic_io_object< SocketAcceptorService >, public socket_base
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of an acceptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of an acceptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Accept a new connection. Accept a new connection and obtain the endpoint of the peer. |
|
|
Assigns an existing native acceptor to the acceptor. |
|
|
Start an asynchronous accept. |
|
|
Construct an acceptor without opening it. Construct an open acceptor. Construct an acceptor opened on the given endpoint. Construct a basic_socket_acceptor on an existing native acceptor. Move-construct a basic_socket_acceptor from another. Move-construct a basic_socket_acceptor from an acceptor of another protocol type. |
|
|
Bind the acceptor to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the acceptor. |
|
|
Close the acceptor. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the acceptor. |
|
|
Perform an IO control command on the acceptor. |
|
|
Determine whether the acceptor is open. |
|
|
Place the acceptor into the state where it will listen for new connections. |
|
|
Get the local endpoint of the acceptor. |
|
|
(Deprecated: Use native_handle().) Get the native acceptor representation. |
|
|
Get the native acceptor representation. |
|
|
Gets the non-blocking mode of the native acceptor implementation. Sets the non-blocking mode of the native acceptor implementation. |
|
|
Gets the non-blocking mode of the acceptor. Sets the non-blocking mode of the acceptor. |
|
|
Open the acceptor using the specified protocol. |
|
|
Move-assign a basic_socket_acceptor from another. Move-assign a basic_socket_acceptor from an acceptor of another protocol type. |
|
|
Set an option on the acceptor. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket_acceptor class template
is used for accepting new socket connections.
Distinct objects: Safe.
Shared objects: Unsafe.
Opening a socket acceptor with the SO_REUSEADDR option enabled:
boost::asio::ip::tcp::acceptor acceptor(io_service); boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port); acceptor.open(endpoint.protocol()); acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); acceptor.bind(endpoint); acceptor.listen();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
template< typename Protocol1, typename SocketService> void accept( basic_socket< Protocol1, SocketService > & peer, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0); » more... template< typename Protocol1, typename SocketService> boost::system::error_code accept( basic_socket< Protocol1, SocketService > & peer, boost::system::error_code & ec, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0); » more...
Accept a new connection and obtain the endpoint of the peer.
template< typename SocketService> void accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint); » more... template< typename SocketService> boost::system::error_code accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Accept a new connection.
template< typename Protocol1, typename SocketService> void accept( basic_socket< Protocol1, SocketService > & peer, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0);
This function is used to accept a new connection from a peer into the given socket. The function call will block until a new connection has been accepted successfully or an error occurs.
The socket into which the new connection will be accepted.
Thrown on failure.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::socket socket(io_service); acceptor.accept(socket);
Accept a new connection.
template< typename Protocol1, typename SocketService> boost::system::error_code accept( basic_socket< Protocol1, SocketService > & peer, boost::system::error_code & ec, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0);
This function is used to accept a new connection from a peer into the given socket. The function call will block until a new connection has been accepted successfully or an error occurs.
The socket into which the new connection will be accepted.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::soocket socket(io_service); boost::system::error_code ec; acceptor.accept(socket, ec); if (ec) { // An error occurred. }
Accept a new connection and obtain the endpoint of the peer.
template< typename SocketService> void accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint);
This function is used to accept a new connection from a peer into the given socket, and additionally provide the endpoint of the remote peer. The function call will block until a new connection has been accepted successfully or an error occurs.
The socket into which the new connection will be accepted.
An endpoint object which will receive the endpoint of the remote peer.
Thrown on failure.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint; acceptor.accept(socket, endpoint);
Accept a new connection and obtain the endpoint of the peer.
template< typename SocketService> boost::system::error_code accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint, boost::system::error_code & ec);
This function is used to accept a new connection from a peer into the given socket, and additionally provide the endpoint of the remote peer. The function call will block until a new connection has been accepted successfully or an error occurs.
The socket into which the new connection will be accepted.
An endpoint object which will receive the endpoint of the remote peer.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint; boost::system::error_code ec; acceptor.accept(socket, endpoint, ec); if (ec) { // An error occurred. }
Assigns an existing native acceptor to the acceptor.
void assign( const protocol_type & protocol, const native_handle_type & native_acceptor); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_acceptor, boost::system::error_code & ec); » more...
Assigns an existing native acceptor to the acceptor.
void assign( const protocol_type & protocol, const native_handle_type & native_acceptor);
Assigns an existing native acceptor to the acceptor.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_acceptor, boost::system::error_code & ec);
template< typename Protocol1, typename SocketService, typename AcceptHandler> void-or-deduced async_accept( basic_socket< Protocol1, SocketService > & peer, AcceptHandler handler, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0); » more... template< typename SocketService, typename AcceptHandler> void-or-deduced async_accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint, AcceptHandler handler); » more...
Start an asynchronous accept.
template< typename Protocol1, typename SocketService, typename AcceptHandler> void-or-deduced async_accept( basic_socket< Protocol1, SocketService > & peer, AcceptHandler handler, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0);
This function is used to asynchronously accept a new connection into a socket. The function call always returns immediately.
The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the handler is called.
The handler to be called when the accept operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
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().
void accept_handler(const boost::system::error_code& error) { if (!error) { // Accept succeeded. } } ... boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::socket socket(io_service); acceptor.async_accept(socket, accept_handler);
Start an asynchronous accept.
template< typename SocketService, typename AcceptHandler> void-or-deduced async_accept( basic_socket< protocol_type, SocketService > & peer, endpoint_type & peer_endpoint, AcceptHandler handler);
This function is used to asynchronously accept a new connection into a socket, and additionally obtain the endpoint of the remote peer. The function call always returns immediately.
The socket into which the new connection will be accepted. Ownership of the peer object is retained by the caller, which must guarantee that it is valid until the handler is called.
An endpoint object into which the endpoint of the remote peer will be written. Ownership of the peer_endpoint object is retained by the caller, which must guarantee that it is valid until the handler is called.
The handler to be called when the accept operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
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().
Construct an acceptor without opening it.
explicit basic_socket_acceptor( boost::asio::io_service & io_service); » more...
Construct an open acceptor.
basic_socket_acceptor( boost::asio::io_service & io_service, const protocol_type & protocol); » more...
Construct an acceptor opened on the given endpoint.
basic_socket_acceptor( boost::asio::io_service & io_service, const endpoint_type & endpoint, bool reuse_addr = true); » more...
Construct a basic_socket_acceptor on an existing
native acceptor.
basic_socket_acceptor( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_acceptor); » more...
Move-construct a basic_socket_acceptor from another.
basic_socket_acceptor( basic_socket_acceptor && other); » more...
Move-construct a basic_socket_acceptor from an
acceptor of another protocol type.
template< typename Protocol1, typename SocketAcceptorService1> basic_socket_acceptor( basic_socket_acceptor< Protocol1, SocketAcceptorService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0); » more...
Construct an acceptor without opening it.
basic_socket_acceptor( boost::asio::io_service & io_service);
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.
The io_service object that
the acceptor will use to dispatch handlers for any asynchronous
operations performed on the acceptor.
Construct an open acceptor.
basic_socket_acceptor( boost::asio::io_service & io_service, const protocol_type & protocol);
This constructor creates an acceptor and automatically opens it.
The io_service object that
the acceptor will use to dispatch handlers for any asynchronous
operations performed on the acceptor.
An object specifying protocol parameters to be used.
Thrown on failure.
Construct an acceptor opened on the given endpoint.
basic_socket_acceptor( boost::asio::io_service & io_service, const endpoint_type & endpoint, bool reuse_addr = true);
This constructor creates an acceptor and automatically opens it to listen for new connections on the specified endpoint.
The io_service object that
the acceptor will use to dispatch handlers for any asynchronous
operations performed on the acceptor.
An endpoint on the local machine on which the acceptor will listen for new connections.
Whether the constructor should set the socket option socket_base::reuse_address.
Thrown on failure.
This constructor is equivalent to the following code:
basic_socket_acceptor<Protocol> acceptor(io_service); acceptor.open(endpoint.protocol()); if (reuse_addr) acceptor.set_option(socket_base::reuse_address(true)); acceptor.bind(endpoint); acceptor.listen(listen_backlog);
Construct a basic_socket_acceptor on an
existing native acceptor.
basic_socket_acceptor( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_acceptor);
This constructor creates an acceptor object to hold an existing native acceptor.
The io_service object that
the acceptor will use to dispatch handlers for any asynchronous
operations performed on the acceptor.
An object specifying protocol parameters to be used.
A native acceptor.
Thrown on failure.
Move-construct a basic_socket_acceptor from another.
basic_socket_acceptor( basic_socket_acceptor && other);
This constructor moves an acceptor from one object to another.
The other basic_socket_acceptor
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket_acceptor(io_service&) constructor.
Move-construct a basic_socket_acceptor from an
acceptor of another protocol type.
template< typename Protocol1, typename SocketAcceptorService1> basic_socket_acceptor( basic_socket_acceptor< Protocol1, SocketAcceptorService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
This constructor moves an acceptor from one object to another.
The other basic_socket_acceptor
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket(io_service&) constructor.
Bind the acceptor to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Bind the acceptor to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket acceptor to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket acceptor will be bound.
Thrown on failure.
boost::asio::ip::tcp::acceptor acceptor(io_service); boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), 12345); acceptor.open(endpoint.protocol()); acceptor.bind(endpoint);
Bind the acceptor to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket acceptor to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket acceptor will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::acceptor acceptor(io_service); boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), 12345); acceptor.open(endpoint.protocol()); boost::system::error_code ec; acceptor.bind(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the acceptor.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Cancel all asynchronous operations associated with the acceptor.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Cancel all asynchronous operations associated with the acceptor.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the acceptor.
void close();
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.
Thrown on failure.
Close the acceptor.
boost::system::error_code close( boost::system::error_code & ec);
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.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::system::error_code ec; acceptor.close(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the acceptor.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option); » more... template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec); » more...
Get an option from the acceptor.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option);
This function is used to get the current value of an option on the acceptor.
The option value to be obtained from the acceptor.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::acceptor::reuse_address option; acceptor.get_option(option); bool is_set = option.get();
Get an option from the acceptor.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec);
This function is used to get the current value of an option on the acceptor.
The option value to be obtained from the acceptor.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::acceptor::reuse_address option; boost::system::error_code ec; acceptor.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.get();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the acceptor.
template< typename IoControlCommand> void io_control( IoControlCommand & command); » more... template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Perform an IO control command on the acceptor.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the acceptor.
The IO control command to be performed on the acceptor.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::acceptor::non_blocking_io command(true); socket.io_control(command);
Perform an IO control command on the acceptor.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the acceptor.
The IO control command to be performed on the acceptor.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::acceptor::non_blocking_io command(true); boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Place the acceptor into the state where it will listen for new connections.
void listen( int backlog = socket_base::max_connections); » more... boost::system::error_code listen( int backlog, boost::system::error_code & ec); » more...
Place the acceptor into the state where it will listen for new connections.
void listen( int backlog = socket_base::max_connections);
This function puts the socket acceptor into the state where it may accept new connections.
The maximum length of the queue of pending connections.
Thrown on failure.
Place the acceptor into the state where it will listen for new connections.
boost::system::error_code listen( int backlog, boost::system::error_code & ec);
This function puts the socket acceptor into the state where it may accept new connections.
The maximum length of the queue of pending connections.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::system::error_code ec; acceptor.listen(boost::asio::socket_base::max_connections, ec); if (ec) { // An error occurred. }
Get the local endpoint of the acceptor.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Get the local endpoint of the acceptor.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the acceptor.
An object that represents the local endpoint of the acceptor.
Thrown on failure.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();
Get the local endpoint of the acceptor.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the acceptor.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the acceptor. Returns a default-constructed endpoint object if an error occurred and the error handler did not throw an exception.
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
(Deprecated: Use native_handle().) Get the native acceptor representation.
native_type native();
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.
Get the native acceptor representation.
native_handle_type native_handle();
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.
The native representation of an acceptor.
typedef SocketAcceptorService::native_handle_type native_handle_type;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native acceptor implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native acceptor implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native acceptor implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native acceptor. This mode has no effect on the behaviour of the acceptor object's synchronous operations.
true if the underlying acceptor
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the acceptor object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native acceptor.
Sets the non-blocking mode of the native acceptor implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native acceptor. It has no effect on the behaviour of the acceptor object's synchronous operations.
If true, the underlying
acceptor is put into non-blocking mode and direct system calls
may fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
Sets the non-blocking mode of the native acceptor implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native acceptor. It has no effect on the behaviour of the acceptor object's synchronous operations.
If true, the underlying
acceptor is put into non-blocking mode and direct system calls
may fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
(Deprecated: Use native_handle_type.) The native representation of an acceptor.
typedef SocketAcceptorService::native_handle_type native_type;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the acceptor.
bool non_blocking() const; » more...
Sets the non-blocking mode of the acceptor.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the acceptor.
bool non_blocking() const;
true if the acceptor's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Sets the non-blocking mode of the acceptor.
void non_blocking( bool mode);
If true, the acceptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Sets the non-blocking mode of the acceptor.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the acceptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Open the acceptor using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Open the acceptor using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket acceptor so that it will use the specified protocol.
An object specifying which protocol is to be used.
Thrown on failure.
boost::asio::ip::tcp::acceptor acceptor(io_service); acceptor.open(boost::asio::ip::tcp::v4());
Open the acceptor using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket acceptor so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::acceptor acceptor(io_service); boost::system::error_code ec; acceptor.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Move-assign a basic_socket_acceptor from another.
basic_socket_acceptor & operator=( basic_socket_acceptor && other); » more...
Move-assign a basic_socket_acceptor from an
acceptor of another protocol type.
template< typename Protocol1, typename SocketAcceptorService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_socket_acceptor >::type & operator=( basic_socket_acceptor< Protocol1, SocketAcceptorService1 > && other); » more...
Move-assign a basic_socket_acceptor from another.
basic_socket_acceptor & operator=( basic_socket_acceptor && other);
This assignment operator moves an acceptor from one object to another.
The other basic_socket_acceptor
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket_acceptor(io_service&) constructor.
Move-assign a basic_socket_acceptor from an
acceptor of another protocol type.
template< typename Protocol1, typename SocketAcceptorService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_socket_acceptor >::type & operator=( basic_socket_acceptor< Protocol1, SocketAcceptorService1 > && other);
This assignment operator moves an acceptor from one object to another.
The other basic_socket_acceptor
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_socket(io_service&) constructor.
typedef Protocol protocol_type;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef SocketAcceptorService service_type;
Header: boost/asio/basic_socket_acceptor.hpp
Convenience header: boost/asio.hpp
Set an option on the acceptor.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option); » more... template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Set an option on the acceptor.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the acceptor.
The new option value to be set on the acceptor.
Thrown on failure.
Setting the SOL_SOCKET/SO_REUSEADDR option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::acceptor::reuse_address option(true); acceptor.set_option(option);
Set an option on the acceptor.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the acceptor.
The new option value to be set on the acceptor.
Set to indicate what error occurred, if any.
Setting the SOL_SOCKET/SO_REUSEADDR option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::ip::tcp::acceptor::reuse_address option(true); boost::system::error_code ec; acceptor.set_option(option, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Iostream interface for a socket.
template< typename Protocol, typename StreamSocketService = stream_socket_service<Protocol>, typename Time = boost::posix_time::ptime, typename TimeTraits = boost::asio::time_traits<Time>, typename TimerService = deadline_timer_service<Time, TimeTraits>> class basic_socket_iostream
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The endpoint type. |
|
|
The time type. |
|
Name |
Description |
|---|---|
|
Construct a basic_socket_iostream without establishing a connection. Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Close the connection. |
|
|
Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Get the last error associated with the stream. |
|
|
Get the stream's expiry time as an absolute time. Set the stream's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the stream's expiry time relative to now. |
|
|
Return a pointer to the underlying streambuf. |
Header: boost/asio/basic_socket_iostream.hpp
Convenience header: boost/asio.hpp
Construct a basic_socket_iostream without
establishing a connection.
basic_socket_iostream(); » more...
Establish a connection to an endpoint corresponding to a resolver query.
template< typename T1, ... , typename TN> explicit basic_socket_iostream( T1 t1, ... , TN tn); » more...
Construct a basic_socket_iostream without
establishing a connection.
basic_socket_iostream();
Establish a connection to an endpoint corresponding to a resolver query.
template< typename T1, ... , typename TN> basic_socket_iostream( T1 t1, ... , TN tn);
This constructor automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object.
Establish a connection to an endpoint corresponding to a resolver query.
template< typename T1, ... , typename TN> void connect( T1 t1, ... , TN tn);
This function automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object.
typedef TimeTraits::duration_type duration_type;
Header: boost/asio/basic_socket_iostream.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_socket_iostream.hpp
Convenience header: boost/asio.hpp
Get the last error associated with the stream.
const boost::system::error_code & error() const;
An error_code corresponding
to the last error from the stream.
To print the error associated with a failure to establish a connection:
tcp::iostream s("www.boost.org", "http"); if (!s) { std::cout << "Error: " << s.error().message() << std::endl; }
Get the stream's expiry time as an absolute time.
time_type expires_at() const; » more...
Set the stream's expiry time as an absolute time.
void expires_at( const time_type & expiry_time); » more...
Get the stream's expiry time as an absolute time.
time_type expires_at() const;
An absolute time value representing the stream's expiry time.
Set the stream's expiry time as an absolute time.
void expires_at( const time_type & expiry_time);
This function sets the expiry time associated with the stream. Stream
operations performed after this time (where the operations cannot be
completed using the internal buffers) will fail with the error boost::asio::error::operation_aborted.
The expiry time to be used for the stream.
Get the timer's expiry time relative to now.
duration_type expires_from_now() const; » more...
Set the stream's expiry time relative to now.
void expires_from_now( const duration_type & expiry_time); » more...
Get the timer's expiry time relative to now.
duration_type expires_from_now() const;
A relative time value representing the stream's expiry time.
Set the stream's expiry time relative to now.
void expires_from_now( const duration_type & expiry_time);
This function sets the expiry time associated with the stream. Stream
operations performed after this time (where the operations cannot be
completed using the internal buffers) will fail with the error boost::asio::error::operation_aborted.
The expiry time to be used for the timer.
Return a pointer to the underlying streambuf.
basic_socket_streambuf< Protocol, StreamSocketService, Time, TimeTraits, TimerService > * rdbuf() const;
typedef TimeTraits::time_type time_type;
Header: boost/asio/basic_socket_iostream.hpp
Convenience header: boost/asio.hpp
Iostream streambuf for a socket.
template< typename Protocol, typename StreamSocketService = stream_socket_service<Protocol>, typename Time = boost::posix_time::ptime, typename TimeTraits = boost::asio::time_traits<Time>, typename TimerService = deadline_timer_service<Time, TimeTraits>> class basic_socket_streambuf : public basic_socket< Protocol, StreamSocketService >
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
The duration type. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
|
The time type. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket_streambuf without establishing a connection. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the connection. Close the socket. |
|
|
Establish a connection. Connect the socket to the specified endpoint. |
|
|
Get the stream buffer's expiry time as an absolute time. Set the stream buffer's expiry time as an absolute time. |
|
|
Get the stream buffer's expiry time relative to now. Set the stream buffer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Get the last error associated with the stream buffer. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
|
Destructor flushes buffered data. |
|
Name |
Description |
|---|---|
|
Get the last error associated with the stream buffer. |
|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
|
Name |
Description |
|---|---|
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket);
Inherited from basic_socket.
Assign an existing native socket to the socket.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Inherited from basic_socket.
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( const endpoint_type & peer_endpoint, ConnectHandler handler);
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.
The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.
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:
void handler( const boost::system::error_code& error // Result of operation );
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().
void connect_handler(const boost::system::error_code& error) { if (!error) { // Connect succeeded. } } ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.async_connect(endpoint, connect_handler);
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const; » more... bool at_mark( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
A bool indicating whether the socket is at the out-of-band data mark.
Thrown on failure.
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark( boost::system::error_code & ec) const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
Set to indicate what error occurred, if any.
A bool indicating whether the socket is at the out-of-band data mark.
Determine the number of bytes available for reading.
std::size_t available() const; » more... std::size_t available( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available() const;
This function is used to determine the number of bytes that may be read without blocking.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Thrown on failure.
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available( boost::system::error_code & ec) const;
This function is used to determine the number of bytes that may be read without blocking.
Set to indicate what error occurred, if any.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Construct a basic_socket_streambuf without
establishing a connection.
basic_socket_streambuf();
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345));
Inherited from basic_socket.
Bind the socket to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); boost::system::error_code ec; socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345), ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the socket.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
basic_socket_streambuf< Protocol, StreamSocketService, Time, TimeTraits, TimerService > * close(); » more...
Close the socket.
boost::system::error_code close( boost::system::error_code & ec); » more...
Close the connection.
basic_socket_streambuf< Protocol, StreamSocketService, Time, TimeTraits, TimerService > * close();
this if a connection was
successfully established, a null pointer otherwise.
Inherited from basic_socket.
Close the socket.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.close(ec); if (ec) { // An error occurred. }
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
basic_socket_streambuf< Protocol, StreamSocketService, Time, TimeTraits, TimerService > * connect( const endpoint_type & endpoint); » more... template< typename T1, ... , typename TN> basic_socket_streambuf< Protocol, StreamSocketService > * connect( T1 t1, ... , TN tn); » more...
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Establish a connection.
basic_socket_streambuf< Protocol, StreamSocketService, Time, TimeTraits, TimerService > * connect( const endpoint_type & endpoint);
This function establishes a connection to the specified endpoint.
this if a connection was
successfully established, a null pointer otherwise.
Establish a connection.
template< typename T1, ... , typename TN> basic_socket_streambuf< Protocol, StreamSocketService > * connect( T1 t1, ... , TN tn);
This function automatically establishes a connection based on the supplied resolver query parameters. The arguments are used to construct a resolver query object.
this if a connection was
successfully established, a null pointer otherwise.
Inherited from basic_socket.
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec);
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.
The remote endpoint to which the socket will be connected.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); boost::system::error_code ec; socket.connect(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
typedef TimeTraits::duration_type duration_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Get the last error associated with the stream buffer.
virtual const boost::system::error_code & error() const;
An error_code corresponding
to the last error from the stream buffer.
Get the stream buffer's expiry time as an absolute time.
time_type expires_at() const; » more...
Set the stream buffer's expiry time as an absolute time.
void expires_at( const time_type & expiry_time); » more...
Get the stream buffer's expiry time as an absolute time.
time_type expires_at() const;
An absolute time value representing the stream buffer's expiry time.
Set the stream buffer's expiry time as an absolute time.
void expires_at( const time_type & expiry_time);
This function sets the expiry time associated with the stream. Stream
operations performed after this time (where the operations cannot be
completed using the internal buffers) will fail with the error boost::asio::error::operation_aborted.
The expiry time to be used for the stream.
Get the stream buffer's expiry time relative to now.
duration_type expires_from_now() const; » more...
Set the stream buffer's expiry time relative to now.
void expires_from_now( const duration_type & expiry_time); » more...
Get the stream buffer's expiry time relative to now.
duration_type expires_from_now() const;
A relative time value representing the stream buffer's expiry time.
Set the stream buffer's expiry time relative to now.
void expires_from_now( const duration_type & expiry_time);
This function sets the expiry time associated with the stream. Stream
operations performed after this time (where the operations cannot be
completed using the internal buffers) will fail with the error boost::asio::error::operation_aborted.
The expiry time to be used for the timer.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the socket.
void get_option( GettableSocketOption & option) const; » more... boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; socket.get_option(option); bool is_set = option.value();
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; boost::system::error_code ec; socket.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.value();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
void io_control( IoControlCommand & command); » more... boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; socket.io_control(command); std::size_t bytes_readable = command.get();
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
friend struct io_handler();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Get the local endpoint of the socket.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the socket.
An object that represents the local endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec); if (ec) { // An error occurred. }
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from basic_socket.
Get a reference to the lowest layer.
lowest_layer_type & 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.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
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.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
A basic_socket is always the lowest
layer.
typedef basic_socket< Protocol, StreamSocketService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
Inherited from basic_socket.
(Deprecated: Use native_handle().) Get the native socket representation.
native_type native();
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.
Inherited from basic_socket.
Get the native socket representation.
native_handle_type native_handle();
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.
Inherited from basic_socket.
The native representation of a socket.
typedef StreamSocketService::native_handle_type native_handle_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
true if the underlying socket
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
(Deprecated: Use native_handle_type.) The native representation of a socket.
typedef StreamSocketService::native_handle_type native_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking() const; » more...
Sets the non-blocking mode of the socket.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the socket.
bool non_blocking() const;
true if the socket's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
void non_blocking( bool mode);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket so that it will use the specified protocol.
An object specifying protocol parameters to be used.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4());
Inherited from basic_socket.
Open the socket using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::system::error_code ec; socket.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Inherited from basic_socket.
typedef Protocol protocol_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Get the last error associated with the stream buffer.
const boost::system::error_code & puberror() const;
An error_code corresponding
to the last error from the stream buffer.
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const; » more... endpoint_type remote_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const;
This function is used to obtain the remote endpoint of the socket.
An object that represents the remote endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the remote endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef StreamSocketService service_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
void set_option( const SettableSocketOption & option); » more... boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Thrown on failure.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Set to indicate what error occurred, if any.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); boost::system::error_code ec; socket.set_option(option, ec); if (ec) { // An error occurred. }
Disable sends or receives on the socket.
void shutdown( shutdown_type what); » more... boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Disable sends or receives on the socket.
void shutdown( shutdown_type what);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Thrown on failure.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
Inherited from basic_socket.
Disable sends or receives on the socket.
boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Set to indicate what error occurred, if any.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
typedef TimeTraits::time_type time_type;
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
friend struct timer_handler();
Header: boost/asio/basic_socket_streambuf.hpp
Convenience header: boost/asio.hpp
Provides stream-oriented socket functionality.
template< typename Protocol, typename StreamSocketService = stream_socket_service<Protocol>> class basic_stream_socket : public basic_socket< Protocol, StreamSocketService >
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Start an asynchronous write. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_stream_socket without opening it. Construct and open a basic_stream_socket. Construct a basic_stream_socket, opening it and binding it to the given local endpoint. Construct a basic_stream_socket on an existing native socket. Move-construct a basic_stream_socket from another. Move-construct a basic_stream_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_stream_socket from another. Move-assign a basic_stream_socket from a socket of another protocol type. |
|
|
Read some data from the socket. |
|
|
Receive some data on the socket. Receive some data on a connected socket. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
|
Write some data to the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_stream_socket class template
provides asynchronous and blocking stream-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket); » more... boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Assign an existing native socket to the socket.
void assign( const protocol_type & protocol, const native_handle_type & native_socket);
Inherited from basic_socket.
Assign an existing native socket to the socket.
boost::system::error_code assign( const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Inherited from basic_socket.
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( const endpoint_type & peer_endpoint, ConnectHandler handler);
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.
The remote endpoint to which the socket will be connected. Copies will be made of the endpoint object as required.
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:
void handler( const boost::system::error_code& error // Result of operation );
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().
void connect_handler(const boost::system::error_code& error) { if (!error) { // Connect succeeded. } } ... boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.async_connect(endpoint, connect_handler);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read data from the stream socket. The function call always returns immediately.
One or more buffers into which the data will be read. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. );
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().
The read operation may not read all of the requested number of bytes. Consider
using the async_read function if you need
to ensure that the requested amount of data is read before the asynchronous
operation completes.
To read into a single data buffer use the buffer function as follows:
socket.async_read_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, ReadHandler handler); » more... template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler); » more...
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously receive data from the stream socket. The function call always returns immediately.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
The receive operation may not receive all of the requested number of
bytes. Consider using the async_read function if you need
to ensure that the requested amount of data is received before the asynchronous
operation completes.
To receive into a single data buffer use the buffer function as follows:
socket.async_receive(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler);
This function is used to asynchronously receive data from the stream socket. The function call always returns immediately.
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.
Flags specifying how the receive call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes received. );
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().
The receive operation may not receive all of the requested number of
bytes. Consider using the async_read function if you need
to ensure that the requested amount of data is received before the asynchronous
operation completes.
To receive into a single data buffer use the buffer function as follows:
socket.async_receive(boost::asio::buffer(data, size), 0, handler);
See the 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 ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, WriteHandler handler); » more... template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler); » more...
Start an asynchronous send.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously send data on the stream socket. The function call always returns immediately.
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.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
The send operation may not transmit all of the data to the peer. Consider
using the async_write function if you
need to ensure that all data is written before the asynchronous operation
completes.
To send a single data buffer use the buffer function as follows:
socket.async_send(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous send.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
This function is used to asynchronously send data on the stream socket. The function call always returns immediately.
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.
Flags specifying how the send call is to be made.
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:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes sent. );
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().
The send operation may not transmit all of the data to the peer. Consider
using the async_write function if you
need to ensure that all data is written before the asynchronous operation
completes.
To send a single data buffer use the buffer function as follows:
socket.async_send(boost::asio::buffer(data, size), 0, handler);
See the 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-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write data to the stream socket. The function call always returns immediately.
One or more data buffers to be written to 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. );
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().
The write operation may not transmit all of the data to the peer. Consider
using the async_write function if you need
to ensure that all data is written before the asynchronous operation completes.
To write a single data buffer use the buffer function as follows:
socket.async_write_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const; » more... bool at_mark( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark() const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
A bool indicating whether the socket is at the out-of-band data mark.
Thrown on failure.
Inherited from basic_socket.
Determine whether the socket is at the out-of-band data mark.
bool at_mark( boost::system::error_code & ec) const;
This function is used to check whether the socket input is currently positioned at the out-of-band data mark.
Set to indicate what error occurred, if any.
A bool indicating whether the socket is at the out-of-band data mark.
Determine the number of bytes available for reading.
std::size_t available() const; » more... std::size_t available( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available() const;
This function is used to determine the number of bytes that may be read without blocking.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Thrown on failure.
Inherited from basic_socket.
Determine the number of bytes available for reading.
std::size_t available( boost::system::error_code & ec) const;
This function is used to determine the number of bytes that may be read without blocking.
Set to indicate what error occurred, if any.
The number of bytes that may be read without blocking, or 0 if an error occurs.
Construct a basic_stream_socket without opening
it.
explicit basic_stream_socket( boost::asio::io_service & io_service); » more...
Construct and open a basic_stream_socket.
basic_stream_socket( boost::asio::io_service & io_service, const protocol_type & protocol); » more...
Construct a basic_stream_socket, opening it
and binding it to the given local endpoint.
basic_stream_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint); » more...
Construct a basic_stream_socket on an existing
native socket.
basic_stream_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket); » more...
Move-construct a basic_stream_socket from another.
basic_stream_socket( basic_stream_socket && other); » more...
Move-construct a basic_stream_socket from a socket
of another protocol type.
template< typename Protocol1, typename StreamSocketService1> basic_stream_socket( basic_stream_socket< Protocol1, StreamSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0); » more...
Construct a basic_stream_socket without
opening it.
basic_stream_socket( boost::asio::io_service & io_service);
This constructor creates a stream socket without opening it. The socket needs to be opened and then connected or accepted before data can be sent or received on it.
The io_service object that
the stream socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
Construct and open a basic_stream_socket.
basic_stream_socket( boost::asio::io_service & io_service, const protocol_type & protocol);
This constructor creates and opens a stream socket. The socket needs to be connected or accepted before data can be sent or received on it.
The io_service object that
the stream socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An object specifying protocol parameters to be used.
Thrown on failure.
Construct a basic_stream_socket, opening
it and binding it to the given local endpoint.
basic_stream_socket( boost::asio::io_service & io_service, const endpoint_type & endpoint);
This constructor creates a stream 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.
The io_service object that
the stream socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An endpoint on the local machine to which the stream socket will be bound.
Thrown on failure.
Construct a basic_stream_socket on an existing
native socket.
basic_stream_socket( boost::asio::io_service & io_service, const protocol_type & protocol, const native_handle_type & native_socket);
This constructor creates a stream socket object to hold an existing native socket.
The io_service object that
the stream socket will use to dispatch handlers for any asynchronous
operations performed on the socket.
An object specifying protocol parameters to be used.
The new underlying socket implementation.
Thrown on failure.
Move-construct a basic_stream_socket from another.
basic_stream_socket( basic_stream_socket && other);
This constructor moves a stream socket from one object to another.
The other basic_stream_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_stream_socket(io_service&) constructor.
Move-construct a basic_stream_socket from a socket
of another protocol type.
template< typename Protocol1, typename StreamSocketService1> basic_stream_socket( basic_stream_socket< Protocol1, StreamSocketService1 > && other, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
This constructor moves a stream socket from one object to another.
The other basic_stream_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_stream_socket(io_service&) constructor.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint); » more... boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Bind the socket to the given local endpoint.
void bind( const endpoint_type & endpoint);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345));
Inherited from basic_socket.
Bind the socket to the given local endpoint.
boost::system::error_code bind( const endpoint_type & endpoint, boost::system::error_code & ec);
This function binds the socket to the specified endpoint on the local machine.
An endpoint on the local machine to which the socket will be bound.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4()); boost::system::error_code ec; socket.bind(boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 12345), ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the socket.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
void cancel();
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Thrown on failure.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
Inherited from basic_socket.
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous connect, send and receive
operations to finish immediately, and the handlers for cancelled operations
will be passed the boost::asio::error::operation_aborted
error.
Set to indicate what error occurred, if any.
Calls to cancel()
will always fail with boost::asio::error::operation_not_supported
when run on Windows XP, Windows Server 2003, and earlier versions of
Windows, unless BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo
function has two issues that should be considered before enabling its
use:
For portable cancellation, consider using one of the following alternatives:
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.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from basic_socket.
Close the socket.
void close();
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Inherited from basic_socket.
Close the socket.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the socket. Any asynchronous send, receive
or connect operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.close(ec); if (ec) { // An error occurred. }
For portable behaviour with respect to graceful closure of a connected
socket, call shutdown() before closing the socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_endpoint); » more... boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Connect the socket to the specified endpoint.
void connect( const endpoint_type & peer_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.
The remote endpoint to which the socket will be connected.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); socket.connect(endpoint);
Inherited from basic_socket.
Connect the socket to the specified endpoint.
boost::system::error_code connect( const endpoint_type & peer_endpoint, boost::system::error_code & ec);
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.
The remote endpoint to which the socket will be connected.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("1.2.3.4"), 12345); boost::system::error_code ec; socket.connect(endpoint, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get an option from the socket.
void get_option( GettableSocketOption & option) const; » more... boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> void get_option( GettableSocketOption & option) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Thrown on failure.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; socket.get_option(option); bool is_set = option.value();
Inherited from basic_socket.
Get an option from the socket.
template< typename GettableSocketOption> boost::system::error_code get_option( GettableSocketOption & option, boost::system::error_code & ec) const;
This function is used to get the current value of an option on the socket.
The option value to be obtained from the socket.
Set to indicate what error occurred, if any.
Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::keep_alive option; boost::system::error_code ec; socket.get_option(option, ec); if (ec) { // An error occurred. } bool is_set = option.value();
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
void io_control( IoControlCommand & command); » more... boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; socket.io_control(command); std::size_t bytes_readable = command.get();
Inherited from basic_socket.
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the socket.
The IO control command to be performed on the socket.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::socket::bytes_readable command; boost::system::error_code ec; socket.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Inherited from socket_base.
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Get the local endpoint of the socket.
endpoint_type local_endpoint() const; » more... endpoint_type local_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint() const;
This function is used to obtain the locally bound endpoint of the socket.
An object that represents the local endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
Inherited from basic_socket.
Get the local endpoint of the socket.
endpoint_type local_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the locally bound endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the local endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec); if (ec) { // An error occurred. }
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from basic_socket.
Get a reference to the lowest layer.
lowest_layer_type & 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.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
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.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from basic_socket.
A basic_socket is always the lowest
layer.
typedef basic_socket< Protocol, StreamSocketService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_socket without opening it. Construct and open a basic_socket. Construct a basic_socket, opening it and binding it to the given local endpoint. Construct a basic_socket on an existing native socket. Move-construct a basic_socket from another. Move-construct a basic_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_socket from another. Move-assign a basic_socket from a socket of another protocol type. |
|
|
Get the remote endpoint of the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket
class template provides functionality that is common to both stream-oriented
and datagram-oriented sockets.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Inherited from socket_base.
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Inherited from socket_base.
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Inherited from socket_base.
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
static const int message_out_of_band = implementation_defined;
Inherited from socket_base.
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
Inherited from basic_socket.
(Deprecated: Use native_handle().) Get the native socket representation.
native_type native();
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.
Inherited from basic_socket.
Get the native socket representation.
native_handle_type native_handle();
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.
The native representation of a socket.
typedef StreamSocketService::native_handle_type native_handle_type;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native socket. This mode has no effect on the behaviour of the socket object's synchronous operations.
true if the underlying socket
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the socket object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native socket.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
Inherited from basic_socket.
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native socket. It has no effect on the behaviour of the socket object's synchronous operations.
If true, the underlying
socket is put into non-blocking mode and direct system calls may
fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
This function is intended to allow the encapsulation of arbitrary non-blocking
system calls as asynchronous operations, in a way that is transparent
to the user of the socket object. The following example illustrates how
Linux's sendfile system
call might be encapsulated:
template <typename Handler> struct sendfile_op { tcp::socket& sock_; int fd_; Handler handler_; off_t offset_; std::size_t total_bytes_transferred_; // Function call operator meeting WriteHandler requirements. // Used as the handler for the async_write_some operation. void operator()(boost::system::error_code ec, std::size_t) { // Put the underlying socket into non-blocking mode. if (!ec) if (!sock_.native_non_blocking()) sock_.native_non_blocking(true, ec); if (!ec) { for (;;) { // Try the system call. errno = 0; int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536); ec = boost::system::error_code(n < 0 ? errno : 0, boost::asio::error::get_system_category()); total_bytes_transferred_ += ec ? 0 : n; // Retry operation immediately if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block || ec == boost::asio::error::try_again) { // We have to wait for the socket to become ready again. sock_.async_write_some(boost::asio::null_buffers(), *this); return; } if (ec || n == 0) { // An error occurred, or we have reached the end of the file. // Either way we must exit the loop so we can call the handler. break; } // Loop around to try calling sendfile again. } } // Pass result back to user's handler. handler_(ec, total_bytes_transferred_); } }; template <typename Handler> void async_sendfile(tcp::socket& sock, int fd, Handler h) { sendfile_op<Handler> op = { sock, fd, h, 0, 0 }; sock.async_write_some(boost::asio::null_buffers(), op); }
(Deprecated: Use native_handle_type.) The native representation of a socket.
typedef StreamSocketService::native_handle_type native_type;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking() const; » more...
Sets the non-blocking mode of the socket.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Gets the non-blocking mode of the socket.
bool non_blocking() const;
true if the socket's synchronous
operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
void non_blocking( bool mode);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from basic_socket.
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the socket's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from socket_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type()); » more... boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Open the socket using the specified protocol.
void open( const protocol_type & protocol = protocol_type());
This function opens the socket so that it will use the specified protocol.
An object specifying protocol parameters to be used.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); socket.open(boost::asio::ip::tcp::v4());
Inherited from basic_socket.
Open the socket using the specified protocol.
boost::system::error_code open( const protocol_type & protocol, boost::system::error_code & ec);
This function opens the socket so that it will use the specified protocol.
An object specifying which protocol is to be used.
Set to indicate what error occurred, if any.
boost::asio::ip::tcp::socket socket(io_service); boost::system::error_code ec; socket.open(boost::asio::ip::tcp::v4(), ec); if (ec) { // An error occurred. }
Move-assign a basic_stream_socket from another.
basic_stream_socket & operator=( basic_stream_socket && other); » more...
Move-assign a basic_stream_socket from a socket
of another protocol type.
template< typename Protocol1, typename StreamSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_stream_socket >::type & operator=( basic_stream_socket< Protocol1, StreamSocketService1 > && other); » more...
Move-assign a basic_stream_socket from another.
basic_stream_socket & operator=( basic_stream_socket && other);
This assignment operator moves a stream socket from one object to another.
The other basic_stream_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_stream_socket(io_service&) constructor.
Move-assign a basic_stream_socket from a socket
of another protocol type.
template< typename Protocol1, typename StreamSocketService1> enable_if< is_convertible< Protocol1, Protocol >::value, basic_stream_socket >::type & operator=( basic_stream_socket< Protocol1, StreamSocketService1 > && other);
This assignment operator moves a stream socket from one object to another.
The other basic_stream_socket object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_stream_socket(io_service&) constructor.
typedef Protocol protocol_type;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Read some data from the socket.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the socket.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
This function is used to read data from the stream socket. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
The number of bytes read.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To read into a single data buffer use the buffer function as follows:
socket.read_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Read some data from the socket.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read data from the stream socket. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes read. Returns 0 if an error occurred.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Receive some data on the socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags); » more...
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Receive some data on the socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers);
This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.
One or more buffers into which the data will be received.
The number of bytes received.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The receive operation may not receive all of the requested number of
bytes. Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To receive into a single data buffer use the buffer function as follows:
socket.receive(boost::asio::buffer(data, size));
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive some data on the socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags);
This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
The number of bytes received.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The receive operation may not receive all of the requested number of
bytes. Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To receive into a single data buffer use the buffer function as follows:
socket.receive(boost::asio::buffer(data, size), 0);
See the buffer
documentation for information on receiving into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Receive some data on a connected socket.
template< typename MutableBufferSequence> std::size_t receive( const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
This function is used to receive data on the stream socket. The function call will block until one or more bytes of data has been received successfully, or until an error occurs.
One or more buffers into which the data will be received.
Flags specifying how the receive call is to be made.
Set to indicate what error occurred, if any.
The number of bytes received. Returns 0 if an error occurred.
The receive operation may not receive all of the requested number of
bytes. Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Inherited from socket_base.
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const; » more... endpoint_type remote_endpoint( boost::system::error_code & ec) const; » more...
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint() const;
This function is used to obtain the remote endpoint of the socket.
An object that represents the remote endpoint of the socket.
Thrown on failure.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
Inherited from basic_socket.
Get the remote endpoint of the socket.
endpoint_type remote_endpoint( boost::system::error_code & ec) const;
This function is used to obtain the remote endpoint of the socket.
Set to indicate what error occurred, if any.
An object that represents the remote endpoint of the socket. Returns a default-constructed endpoint object if an error occurred.
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags); » more... template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec); » more...
Send some data on the socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers);
This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.
One or more data buffers to be sent on the socket.
The number of bytes sent.
Thrown on failure.
The send operation may not transmit all of the data to the peer. Consider
using the write
function if you need to ensure that all data is written before the blocking
operation completes.
To send a single data buffer use the buffer function as follows:
socket.send(boost::asio::buffer(data, size));
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send some data on the socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags);
This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.
One or more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
The number of bytes sent.
Thrown on failure.
The send operation may not transmit all of the data to the peer. Consider
using the write
function if you need to ensure that all data is written before the blocking
operation completes.
To send a single data buffer use the buffer function as follows:
socket.send(boost::asio::buffer(data, size), 0);
See the buffer
documentation for information on sending multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Send some data on the socket.
template< typename ConstBufferSequence> std::size_t send( const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
This function is used to send data on the stream socket. The function call will block until one or more bytes of the data has been sent successfully, or an until error occurs.
One or more data buffers to be sent on the socket.
Flags specifying how the send call is to be made.
Set to indicate what error occurred, if any.
The number of bytes sent. Returns 0 if an error occurred.
The send operation may not transmit all of the data to the peer. Consider
using the write
function if you need to ensure that all data is written before the blocking
operation completes.
Inherited from socket_base.
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from socket_base.
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef StreamSocketService service_type;
Header: boost/asio/basic_stream_socket.hpp
Convenience header: boost/asio.hpp
void set_option( const SettableSocketOption & option); » more... boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> void set_option( const SettableSocketOption & option);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Thrown on failure.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Inherited from basic_socket.
Set an option on the socket.
template< typename SettableSocketOption> boost::system::error_code set_option( const SettableSocketOption & option, boost::system::error_code & ec);
This function is used to set an option on the socket.
The new option value to be set on the socket.
Set to indicate what error occurred, if any.
Setting the IPPROTO_TCP/TCP_NODELAY option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); boost::system::error_code ec; socket.set_option(option, ec); if (ec) { // An error occurred. }
Disable sends or receives on the socket.
void shutdown( shutdown_type what); » more... boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec); » more...
Inherited from basic_socket.
Disable sends or receives on the socket.
void shutdown( shutdown_type what);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Thrown on failure.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
Inherited from basic_socket.
Disable sends or receives on the socket.
boost::system::error_code shutdown( shutdown_type what, boost::system::error_code & ec);
This function is used to disable send operations, receive operations, or both.
Determines what types of operation will no longer be allowed.
Set to indicate what error occurred, if any.
Shutting down the send side of the socket:
boost::asio::ip::tcp::socket socket(io_service); ... boost::system::error_code ec; socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec); if (ec) { // An error occurred. }
Inherited from socket_base.
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Write some data to the socket.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write some data to the socket.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
This function is used to write data to the stream socket. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the socket.
The number of bytes written.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
To write a single data buffer use the buffer function as follows:
socket.write_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Write some data to the socket.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write data to the stream socket. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the socket.
Set to indicate what error occurred, if any.
The number of bytes written. Returns 0 if an error occurred.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
Automatically resizable buffer class based on std::streambuf.
template< typename Allocator = std::allocator<char>> class basic_streambuf : noncopyable
|
Name |
Description |
|---|---|
|
The type used to represent the input sequence as a list of buffers. |
|
|
The type used to represent the output sequence as a list of buffers. |
|
Name |
Description |
|---|---|
|
Construct a basic_streambuf object. |
|
|
Move characters from the output sequence to the input sequence. |
|
|
Remove characters from the input sequence. |
|
|
Get a list of buffers that represents the input sequence. |
|
|
Get the maximum size of the basic_streambuf. |
|
|
Get a list of buffers that represents the output sequence, with the given size. |
|
|
Get the size of the input sequence. |
|
Name |
Description |
|---|---|
|
Override std::streambuf behaviour. |
|
|
Override std::streambuf behaviour. |
The basic_streambuf class
is derived from std::streambuf to associate the streambuf's
input and output sequences with one or more character arrays. These character
arrays are internal to the basic_streambuf
object, but direct access to the array elements is provided to permit them
to be used efficiently with I/O operations. Characters written to the output
sequence of a basic_streambuf
object are appended to the input sequence of the same object.
The basic_streambuf class's
public interface is intended to permit the following implementation strategies:
The constructor for basic_streambuf accepts a size_t argument specifying the maximum
of the sum of the sizes of the input sequence and output sequence. During
the lifetime of the basic_streambuf
object, the following invariant holds:
size() <= max_size()
Any member function that would, if successful, cause the invariant to be
violated shall throw an exception of class std::length_error.
The constructor for basic_streambuf
takes an Allocator argument. A copy of this argument is used for any memory
allocation performed, by the constructor and by all member functions, during
the lifetime of each basic_streambuf
object.
Writing directly from an streambuf to a socket:
boost::asio::streambuf b; std::ostream os(&b); os << "Hello, World!\n"; // try sending some data in input sequence size_t n = sock.send(b.data()); b.consume(n); // sent data is removed from input sequence
Reading from a socket directly into a streambuf:
boost::asio::streambuf b; // reserve 512 bytes in output sequence boost::asio::streambuf::mutable_buffers_type bufs = b.prepare(512); size_t n = sock.receive(bufs); // received data is "committed" from output sequence to input sequence b.commit(n); std::istream is(&b); std::string s; is >> s;
Header: boost/asio/basic_streambuf.hpp
Convenience header: boost/asio.hpp
Construct a basic_streambuf object.
basic_streambuf( std::size_t maximum_size = (std::numeric_limits< std::size_t >::max)(), const Allocator & allocator = Allocator());
Constructs a streambuf with the specified maximum size. The initial size of the streambuf's input sequence is 0.
Move characters from the output sequence to the input sequence.
void commit( std::size_t n);
Appends n characters from
the start of the output sequence to the input sequence. The beginning of
the output sequence is advanced by n
characters.
Requires a preceding call prepare(x)
where x >=
n, and no intervening operations
that modify the input or output sequence.
If n is greater than the
size of the output sequence, the entire output sequence is moved to the
input sequence and no error is issued.
The type used to represent the input sequence as a list of buffers.
typedef implementation_defined const_buffers_type;
Header: boost/asio/basic_streambuf.hpp
Convenience header: boost/asio.hpp
Remove characters from the input sequence.
void consume( std::size_t n);
Removes n characters from
the beginning of the input sequence.
If n is greater than the
size of the input sequence, the entire input sequence is consumed and no
error is issued.
Get a list of buffers that represents the input sequence.
const_buffers_type data() const;
An object of type const_buffers_type
that satisfies ConstBufferSequence requirements, representing all character
arrays in the input sequence.
The returned object is invalidated by any basic_streambuf
member function that modifies the input sequence or output sequence.
Get the maximum size of the basic_streambuf.
std::size_t max_size() const;
The allowed maximum of the sum of the sizes of the input sequence and output sequence.
The type used to represent the output sequence as a list of buffers.
typedef implementation_defined mutable_buffers_type;
Header: boost/asio/basic_streambuf.hpp
Convenience header: boost/asio.hpp
Override std::streambuf behaviour.
int_type overflow( int_type c);
Behaves according to the specification of std::streambuf::overflow(), with the specialisation that std::length_error is thrown if appending the
character to the input sequence would require the condition size() > max_size() to be true.
Get a list of buffers that represents the output sequence, with the given size.
mutable_buffers_type prepare( std::size_t n);
Ensures that the output sequence can accommodate n
characters, reallocating character array objects as necessary.
An object of type mutable_buffers_type
that satisfies MutableBufferSequence requirements, representing character
array objects at the start of the output sequence such that the sum of
the buffer sizes is n.
If size()
+ n
> max_size().
The returned object is invalidated by any basic_streambuf
member function that modifies the input sequence or output sequence.
Get the size of the input sequence.
std::size_t size() const;
The size of the input sequence. The value is equal to that calculated for
s in the following code:
size_t s = 0; const_buffers_type bufs = data(); const_buffers_type::const_iterator i = bufs.begin(); while (i != bufs.end()) { const_buffer buf(*i++); s += buffer_size(buf); }
Provides waitable timer functionality.
template< typename Clock, typename WaitTraits = boost::asio::wait_traits<Clock>, typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits>> class basic_waitable_timer : public basic_io_object< WaitableTimerService >
|
Name |
Description |
|---|---|
|
The clock type. |
|
|
The duration type of the clock. |
|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
The time point type of the clock. |
|
|
The wait traits type. |
|
Name |
Description |
|---|---|
|
Start an asynchronous wait on the timer. |
|
|
Constructor. Constructor to set a particular expiry time as an absolute time. Constructor to set a particular expiry time relative to now. |
|
|
Cancel any asynchronous operations that are waiting on the timer. |
|
|
Cancels one asynchronous operation that is waiting on the timer. |
|
|
Get the timer's expiry time as an absolute time. Set the timer's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the timer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Perform a blocking wait on the timer. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_waitable_timer class template
provides the ability to perform a blocking or asynchronous wait for a timer
to expire.
A waitable timer is always in one of two states: "expired" or "not
expired". If the wait() or async_wait() function is called on an expired timer,
the wait operation will complete immediately.
Most applications will use one of the steady_timer, system_timer or high_resolution_timer typedefs.
This waitable timer functionality is for use with the C++11 standard library's
<chrono> facility, or with the Boost.Chrono library.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing a blocking wait (C++11):
// Construct a timer without setting an expiry time. boost::asio::steady_timer timer(io_service); // Set an expiry time relative to now. timer.expires_from_now(std::chrono::seconds(5)); // Wait for the timer to expire. timer.wait();
Performing an asynchronous wait (C++11):
void handler(const boost::system::error_code& error) { if (!error) { // Timer expired. } } ... // Construct a timer with an absolute expiry time. boost::asio::steady_timer timer(io_service, std::chrono::steady_clock::now() + std::chrono::seconds(60)); // Start an asynchronous wait. timer.async_wait(handler);
Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
void on_some_event() { if (my_timer.expires_from_now(seconds(5)) > 0) { // We managed to cancel the timer. Start new asynchronous wait. my_timer.async_wait(on_timeout); } else { // Too late, timer has already expired! } } void on_timeout(const boost::system::error_code& e) { if (e != boost::asio::error::operation_aborted) { // Timer was not cancelled, take necessary action. } }
boost::asio::basic_waitable_timer::expires_from_now()
function cancels any pending asynchronous waits, and returns the number
of asynchronous waits that were cancelled. If it returns 0 then you were
too late and the wait handler has already been executed, or will soon
be executed. If it returns 1 then the wait handler was successfully cancelled.
boost::asio::error::operation_aborted.
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
Start an asynchronous wait on the timer.
template< typename WaitHandler> void-or-deduced async_wait( WaitHandler handler);
This function may be used to initiate an asynchronous wait against the timer. It always returns immediately.
For each call to async_wait(), the supplied handler will be called
exactly once. The handler will be called when:
boost::asio::error::operation_aborted.
The handler to be called when the timer expires. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
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().
explicit basic_waitable_timer( boost::asio::io_service & io_service); » more...
Constructor to set a particular expiry time as an absolute time.
basic_waitable_timer( boost::asio::io_service & io_service, const time_point & expiry_time); » more...
Constructor to set a particular expiry time relative to now.
basic_waitable_timer( boost::asio::io_service & io_service, const duration & expiry_time); » more...
Constructor.
basic_waitable_timer( boost::asio::io_service & io_service);
This constructor creates a timer without setting an expiry time. The
expires_at()
or expires_from_now()
functions must be called to set an expiry time before the timer can be
waited on.
The io_service object that
the timer will use to dispatch handlers for any asynchronous operations
performed on the timer.
Constructor to set a particular expiry time as an absolute time.
basic_waitable_timer( boost::asio::io_service & io_service, const time_point & expiry_time);
This constructor creates a timer and sets the expiry time.
The io_service object that
the timer will use to dispatch handlers for any asynchronous operations
performed on the timer.
The expiry time to be used for the timer, expressed as an absolute time.
Constructor to set a particular expiry time relative to now.
basic_waitable_timer( boost::asio::io_service & io_service, const duration & expiry_time);
This constructor creates a timer and sets the expiry time.
The io_service object that
the timer will use to dispatch handlers for any asynchronous operations
performed on the timer.
The expiry time to be used for the timer, relative to now.
Cancel any asynchronous operations that are waiting on the timer.
std::size_t cancel(); » more... std::size_t cancel( boost::system::error_code & ec); » more...
Cancel any asynchronous operations that are waiting on the timer.
std::size_t cancel();
This function forces the completion of any pending asynchronous wait
operations against the timer. The handler for each cancelled operation
will be invoked with the boost::asio::error::operation_aborted
error code.
Cancelling the timer does not change the expiry time.
The number of asynchronous operations that were cancelled.
Thrown on failure.
If the timer has already expired when cancel() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancel any asynchronous operations that are waiting on the timer.
std::size_t cancel( boost::system::error_code & ec);
This function forces the completion of any pending asynchronous wait
operations against the timer. The handler for each cancelled operation
will be invoked with the boost::asio::error::operation_aborted
error code.
Cancelling the timer does not change the expiry time.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled.
If the timer has already expired when cancel() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancels one asynchronous operation that is waiting on the timer.
std::size_t cancel_one(); » more... std::size_t cancel_one( boost::system::error_code & ec); » more...
Cancels one asynchronous operation that is waiting on the timer.
std::size_t cancel_one();
This function forces the completion of one pending asynchronous wait
operation against the timer. Handlers are cancelled in FIFO order. The
handler for the cancelled operation will be invoked with the boost::asio::error::operation_aborted error code.
Cancelling the timer does not change the expiry time.
The number of asynchronous operations that were cancelled. That is, either 0 or 1.
Thrown on failure.
If the timer has already expired when cancel_one() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Cancels one asynchronous operation that is waiting on the timer.
std::size_t cancel_one( boost::system::error_code & ec);
This function forces the completion of one pending asynchronous wait
operation against the timer. Handlers are cancelled in FIFO order. The
handler for the cancelled operation will be invoked with the boost::asio::error::operation_aborted error code.
Cancelling the timer does not change the expiry time.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled. That is, either 0 or 1.
If the timer has already expired when cancel_one() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
typedef Clock clock_type;
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
The duration type of the clock.
typedef clock_type::duration duration;
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
Get the timer's expiry time as an absolute time.
time_point expires_at() const; » more...
Set the timer's expiry time as an absolute time.
std::size_t expires_at( const time_point & expiry_time); » more... std::size_t expires_at( const time_point & expiry_time, boost::system::error_code & ec); » more...
Get the timer's expiry time as an absolute time.
time_point expires_at() const;
This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value.
Set the timer's expiry time as an absolute time.
std::size_t expires_at( const time_point & expiry_time);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
The number of asynchronous operations that were cancelled.
Thrown on failure.
If the timer has already expired when expires_at() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Set the timer's expiry time as an absolute time.
std::size_t expires_at( const time_point & expiry_time, boost::system::error_code & ec);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled.
If the timer has already expired when expires_at() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Get the timer's expiry time relative to now.
duration expires_from_now() const; » more...
Set the timer's expiry time relative to now.
std::size_t expires_from_now( const duration & expiry_time); » more... std::size_t expires_from_now( const duration & expiry_time, boost::system::error_code & ec); » more...
Get the timer's expiry time relative to now.
duration expires_from_now() const;
This function may be used to obtain the timer's current expiry time. Whether the timer has expired or not does not affect this value.
Set the timer's expiry time relative to now.
std::size_t expires_from_now( const duration & expiry_time);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
The number of asynchronous operations that were cancelled.
Thrown on failure.
If the timer has already expired when expires_from_now() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Set the timer's expiry time relative to now.
std::size_t expires_from_now( const duration & expiry_time, boost::system::error_code & ec);
This function sets the expiry time. Any pending asynchronous wait operations
will be cancelled. The handler for each cancelled operation will be invoked
with the boost::asio::error::operation_aborted error code.
The expiry time to be used for the timer.
Set to indicate what error occurred, if any.
The number of asynchronous operations that were cancelled.
If the timer has already expired when expires_from_now() is called, then the handlers for asynchronous
wait operations will:
These handlers can no longer be cancelled, and therefore are passed an error code that indicates the successful completion of the wait operation.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef WaitableTimerService service_type;
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
The time point type of the clock.
typedef clock_type::time_point time_point;
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
typedef WaitTraits traits_type;
Header: boost/asio/basic_waitable_timer.hpp
Convenience header: boost/asio.hpp
Perform a blocking wait on the timer.
void wait(); » more... void wait( boost::system::error_code & ec); » more...
Perform a blocking wait on the timer.
void wait();
This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
Thrown on failure.
Perform a blocking wait on the timer.
void wait( boost::system::error_code & ec);
This function is used to wait for the timer to expire. This function blocks and does not return until the timer has expired.
Set to indicate what error occurred, if any.
Context object the represents the currently executing coroutine.
template< typename Handler> class basic_yield_context
|
Name |
Description |
|---|---|
|
The coroutine callee type, used by the implementation. |
|
|
The coroutine caller type, used by the implementation. |
|
Name |
Description |
|---|---|
|
Construct a yield context to represent the specified coroutine. |
|
|
Return a yield context that sets the specified error_code. |
The basic_yield_context class is used
to represent the currently executing stackful coroutine. A basic_yield_context may be passed
as a handler to an asynchronous operation. For example:
template <typename Handler> void my_coroutine(basic_yield_context<Handler> yield) { ... std::size_t n = my_socket.async_read_some(buffer, yield); ... }
The initiating function (async_read_some in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned.
Header: boost/asio/spawn.hpp
Convenience header: None
Construct a yield context to represent the specified coroutine.
basic_yield_context( const detail::weak_ptr< callee_type > & coro, caller_type & ca, Handler & handler);
Most applications do not need to use this constructor. Instead, the spawn()
function passes a yield context as an argument to the coroutine function.
The coroutine callee type, used by the implementation.
typedef implementation_defined callee_type;
When using Boost.Coroutine v1, this type is:
typename coroutine<void()>
When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
push_coroutine<void>
Header: boost/asio/spawn.hpp
Convenience header: None
The coroutine caller type, used by the implementation.
typedef implementation_defined caller_type;
When using Boost.Coroutine v1, this type is:
typename coroutine<void()>::caller_type
When using Boost.Coroutine v2 (unidirectional coroutines), this type is:
pull_coroutine<void>
Header: boost/asio/spawn.hpp
Convenience header: None
Return a yield context that sets the specified error_code.
basic_yield_context operator[]( boost::system::error_code & ec) const;
By default, when a yield context is used with an asynchronous operation, a non-success error_code is converted to system_error and thrown. This operator may be used to specify an error_code object that should instead be set with the asynchronous operation's result. For example:
template <typename Handler> void my_coroutine(basic_yield_context<Handler> yield) { ... std::size_t n = my_socket.async_read_some(buffer, yield[ec]); if (ec) { // An error occurred. } ... }
The boost::asio::buffer function is used to create a buffer
object to represent raw memory, an array of POD elements, a vector of POD
elements, or a std::string.
mutable_buffers_1 buffer( const mutable_buffer & b); » more... mutable_buffers_1 buffer( const mutable_buffer & b, std::size_t max_size_in_bytes); » more... const_buffers_1 buffer( const const_buffer & b); » more... const_buffers_1 buffer( const const_buffer & b, std::size_t max_size_in_bytes); » more... mutable_buffers_1 buffer( void * data, std::size_t size_in_bytes); » more... const_buffers_1 buffer( const void * data, std::size_t size_in_bytes); » more... template< typename PodType, std::size_t N> mutable_buffers_1 buffer( PodType (&data)[N]); » more... template< typename PodType, std::size_t N> mutable_buffers_1 buffer( PodType (&data)[N], std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( const PodType (&data)[N]); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( const PodType (&data)[N], std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> mutable_buffers_1 buffer( boost::array< PodType, N > & data); » more... template< typename PodType, std::size_t N> mutable_buffers_1 buffer( boost::array< PodType, N > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( boost::array< const PodType, N > & data); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( boost::array< const PodType, N > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( const boost::array< PodType, N > & data); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( const boost::array< PodType, N > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> mutable_buffers_1 buffer( std::array< PodType, N > & data); » more... template< typename PodType, std::size_t N> mutable_buffers_1 buffer( std::array< PodType, N > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( std::array< const PodType, N > & data); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( std::array< const PodType, N > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( const std::array< PodType, N > & data); » more... template< typename PodType, std::size_t N> const_buffers_1 buffer( const std::array< PodType, N > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, typename Allocator> mutable_buffers_1 buffer( std::vector< PodType, Allocator > & data); » more... template< typename PodType, typename Allocator> mutable_buffers_1 buffer( std::vector< PodType, Allocator > & data, std::size_t max_size_in_bytes); » more... template< typename PodType, typename Allocator> const_buffers_1 buffer( const std::vector< PodType, Allocator > & data); » more... template< typename PodType, typename Allocator> const_buffers_1 buffer( const std::vector< PodType, Allocator > & data, std::size_t max_size_in_bytes); » more... template< typename Elem, typename Traits, typename Allocator> const_buffers_1 buffer( const std::basic_string< Elem, Traits, Allocator > & data); » more... template< typename Elem, typename Traits, typename Allocator> const_buffers_1 buffer( const std::basic_string< Elem, Traits, Allocator > & data, std::size_t max_size_in_bytes); » more...
A buffer object represents a contiguous region of memory as a 2-tuple consisting
of a pointer and size in bytes. A tuple of the form {void*, size_t} specifies a mutable (modifiable) region
of memory. Similarly, a tuple of the form {const void*, size_t} specifies a const (non-modifiable) region
of memory. These two forms correspond to the classes mutable_buffer and const_buffer, respectively. To mirror
C++'s conversion rules, a mutable_buffer is implicitly convertible
to a const_buffer,
and the opposite conversion is not permitted.
The simplest use case involves reading or writing a single buffer of a specified size:
sock.send(boost::asio::buffer(data, size));
In the above example, the return value of boost::asio::buffer
meets the requirements of the ConstBufferSequence concept so that it may
be directly passed to the socket's write function. A buffer created for modifiable
memory also meets the requirements of the MutableBufferSequence concept.
An individual buffer may be created from a builtin array, std::vector, std::array or boost::array of POD elements. This helps prevent buffer overruns by automatically determining the size of the buffer:
char d1[128]; size_t bytes_transferred = sock.receive(boost::asio::buffer(d1)); std::vector<char> d2(128); bytes_transferred = sock.receive(boost::asio::buffer(d2)); std::array<char, 128> d3; bytes_transferred = sock.receive(boost::asio::buffer(d3)); boost::array<char, 128> d4; bytes_transferred = sock.receive(boost::asio::buffer(d4));
In all three cases above, the buffers created are exactly 128 bytes long.
Note that a vector is never automatically resized when
creating or using a buffer. The buffer size is determined using the vector's
size()
member function, and not its capacity.
The contents of a buffer may be accessed using the buffer_size and buffer_cast functions:
boost::asio::mutable_buffer b1 = ...; std::size_t s1 = boost::asio::buffer_size(b1); unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1); boost::asio::const_buffer b2 = ...; std::size_t s2 = boost::asio::buffer_size(b2); const void* p2 = boost::asio::buffer_cast<const void*>(b2);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
For convenience, the buffer_size function also works
on buffer sequences (that is, types meeting the ConstBufferSequence or MutableBufferSequence
type requirements). In this case, the function returns the total size of
all buffers in the sequence.
The buffer_copy
function may be used to copy raw bytes between individual buffers and buffer
sequences.
In particular, when used with the buffer_size , the buffer_copy function can be used
to linearise a sequence of buffers. For example:
vector<const_buffer> buffers = ...; vector<unsigned char> data(boost::asio::buffer_size(buffers)); boost::asio::buffer_copy(boost::asio::buffer(data), buffers);
Note that buffer_copy is implemented in terms
of memcpy, and consequently
it cannot be used to copy between overlapping memory regions.
A buffer object does not have any ownership of the memory it refers to. It is the responsibility of the application to ensure the memory region remains valid until it is no longer required for an I/O operation. When the memory is no longer available, the buffer is said to have been invalidated.
For the boost::asio::buffer overloads that accept an argument
of type std::vector, the buffer objects returned are invalidated by any vector
operation that also invalidates all references, pointers and iterators referring
to the elements in the sequence (C++ Std, 23.2.4)
For the boost::asio::buffer overloads that accept an argument
of type std::basic_string, the buffer objects returned are invalidated according
to the rules defined for invalidation of references, pointers and iterators
referring to elements of the sequence (C++ Std, 21.3).
Buffer objects may be manipulated using simple arithmetic in a safe way which helps prevent buffer overruns. Consider an array initialised as follows:
boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' };
A buffer object b1 created
using:
b1 = boost::asio::buffer(a);
represents the entire array, { 'a', 'b', 'c',
'd', 'e' }. An optional
second argument to the boost::asio::buffer
function may be used to limit the size, in bytes, of the buffer:
b2 = boost::asio::buffer(a, 3);
such that b2 represents the
data { 'a', 'b',
'c' }.
Even if the size argument exceeds the actual size of the array, the size
of the buffer object created will be limited to the array size.
An offset may be applied to an existing buffer to create a new one:
b3 = b1 + 2;
where b3 will set to represent
{ 'c', 'd',
'e' }.
If the offset exceeds the size of the existing buffer, the newly created
buffer will be empty.
Both an offset and size may be specified to create a buffer that corresponds to a specific range of bytes within an existing buffer:
b4 = boost::asio::buffer(b1 + 1, 3);
so that b4 will refer to
the bytes { 'b', 'c',
'd' }.
To read or write using multiple buffers (i.e. scatter-gather I/O), multiple buffer objects may be assigned into a container that supports the MutableBufferSequence (for read) or ConstBufferSequence (for write) concepts:
char d1[128]; std::vector<char> d2(128); boost::array<char, 128> d3; boost::array<mutable_buffer, 3> bufs1 = { boost::asio::buffer(d1), boost::asio::buffer(d2), boost::asio::buffer(d3) }; bytes_transferred = sock.receive(bufs1); std::vector<const_buffer> bufs2; bufs2.push_back(boost::asio::buffer(d1)); bufs2.push_back(boost::asio::buffer(d2)); bufs2.push_back(boost::asio::buffer(d3)); bytes_transferred = sock.send(bufs2);
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Create a new modifiable buffer from an existing buffer.
mutable_buffers_1 buffer( const mutable_buffer & b);
mutable_buffers_1(b).
Create a new modifiable buffer from an existing buffer.
mutable_buffers_1 buffer( const mutable_buffer & b, std::size_t max_size_in_bytes);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( buffer_cast<void*>(b), min(buffer_size(b), max_size_in_bytes));
Create a new non-modifiable buffer from an existing buffer.
const_buffers_1 buffer( const const_buffer & b);
const_buffers_1(b).
Create a new non-modifiable buffer from an existing buffer.
const_buffers_1 buffer( const const_buffer & b, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( buffer_cast<const void*>(b), min(buffer_size(b), max_size_in_bytes));
Create a new modifiable buffer that represents the given memory range.
mutable_buffers_1 buffer( void * data, std::size_t size_in_bytes);
mutable_buffers_1(data, size_in_bytes).
Create a new non-modifiable buffer that represents the given memory range.
const_buffers_1 buffer( const void * data, std::size_t size_in_bytes);
const_buffers_1(data, size_in_bytes).
Create a new modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> mutable_buffers_1 buffer( PodType (&data)[N]);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( static_cast<void*>(data), N * sizeof(PodType));
Create a new modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> mutable_buffers_1 buffer( PodType (&data)[N], std::size_t max_size_in_bytes);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( static_cast<void*>(data), min(N * sizeof(PodType), max_size_in_bytes));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( const PodType (&data)[N]);
A const_buffers_1
value equivalent to:
const_buffers_1( static_cast<const void*>(data), N * sizeof(PodType));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( const PodType (&data)[N], std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( static_cast<const void*>(data), min(N * sizeof(PodType), max_size_in_bytes));
Create a new modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> mutable_buffers_1 buffer( boost::array< PodType, N > & data);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( data.data(), data.size() * sizeof(PodType));
Create a new modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> mutable_buffers_1 buffer( boost::array< PodType, N > & data, std::size_t max_size_in_bytes);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( data.data(), min(data.size() * sizeof(PodType), max_size_in_bytes));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( boost::array< const PodType, N > & data);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), data.size() * sizeof(PodType));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( boost::array< const PodType, N > & data, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), min(data.size() * sizeof(PodType), max_size_in_bytes));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( const boost::array< PodType, N > & data);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), data.size() * sizeof(PodType));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( const boost::array< PodType, N > & data, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), min(data.size() * sizeof(PodType), max_size_in_bytes));
Create a new modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> mutable_buffers_1 buffer( std::array< PodType, N > & data);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( data.data(), data.size() * sizeof(PodType));
Create a new modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> mutable_buffers_1 buffer( std::array< PodType, N > & data, std::size_t max_size_in_bytes);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( data.data(), min(data.size() * sizeof(PodType), max_size_in_bytes));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( std::array< const PodType, N > & data);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), data.size() * sizeof(PodType));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( std::array< const PodType, N > & data, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), min(data.size() * sizeof(PodType), max_size_in_bytes));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( const std::array< PodType, N > & data);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), data.size() * sizeof(PodType));
Create a new non-modifiable buffer that represents the given POD array.
template< typename PodType, std::size_t N> const_buffers_1 buffer( const std::array< PodType, N > & data, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), min(data.size() * sizeof(PodType), max_size_in_bytes));
Create a new modifiable buffer that represents the given POD vector.
template< typename PodType, typename Allocator> mutable_buffers_1 buffer( std::vector< PodType, Allocator > & data);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( data.size() ? &data[0] : 0, data.size() * sizeof(PodType));
The buffer is invalidated by any vector operation that would also invalidate iterators.
Create a new modifiable buffer that represents the given POD vector.
template< typename PodType, typename Allocator> mutable_buffers_1 buffer( std::vector< PodType, Allocator > & data, std::size_t max_size_in_bytes);
A mutable_buffers_1 value equivalent
to:
mutable_buffers_1( data.size() ? &data[0] : 0, min(data.size() * sizeof(PodType), max_size_in_bytes));
The buffer is invalidated by any vector operation that would also invalidate iterators.
Create a new non-modifiable buffer that represents the given POD vector.
template< typename PodType, typename Allocator> const_buffers_1 buffer( const std::vector< PodType, Allocator > & data);
A const_buffers_1
value equivalent to:
const_buffers_1( data.size() ? &data[0] : 0, data.size() * sizeof(PodType));
The buffer is invalidated by any vector operation that would also invalidate iterators.
Create a new non-modifiable buffer that represents the given POD vector.
template< typename PodType, typename Allocator> const_buffers_1 buffer( const std::vector< PodType, Allocator > & data, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( data.size() ? &data[0] : 0, min(data.size() * sizeof(PodType), max_size_in_bytes));
The buffer is invalidated by any vector operation that would also invalidate iterators.
Create a new non-modifiable buffer that represents the given string.
template< typename Elem, typename Traits, typename Allocator> const_buffers_1 buffer( const std::basic_string< Elem, Traits, Allocator > & data);
const_buffers_1(data.data(), data.size() * sizeof(Elem)).
The buffer is invalidated by any non-const operation called on the given string object.
Create a new non-modifiable buffer that represents the given string.
template< typename Elem, typename Traits, typename Allocator> const_buffers_1 buffer( const std::basic_string< Elem, Traits, Allocator > & data, std::size_t max_size_in_bytes);
A const_buffers_1
value equivalent to:
const_buffers_1( data.data(), min(data.size() * sizeof(Elem), max_size_in_bytes));
The buffer is invalidated by any non-const operation called on the given string object.
The boost::asio::buffer_cast function is used to obtain
a pointer to the underlying memory region associated with a buffer.
template< typename PointerToPodType> PointerToPodType buffer_cast( const mutable_buffer & b); » more... template< typename PointerToPodType> PointerToPodType buffer_cast( const const_buffer & b); » more...
To access the memory of a non-modifiable buffer, use:
boost::asio::const_buffer b1 = ...; const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
To access the memory of a modifiable buffer, use:
boost::asio::mutable_buffer b2 = ...; unsigned char* p2 = boost::asio::buffer_cast<unsigned char*>(b2);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Cast a non-modifiable buffer to a specified pointer to POD type.
template< typename PointerToPodType> PointerToPodType buffer_cast( const mutable_buffer & b);
Cast a non-modifiable buffer to a specified pointer to POD type.
template< typename PointerToPodType> PointerToPodType buffer_cast( const const_buffer & b);
The boost::asio::buffer_copy function is used to copy bytes
from a source buffer (or buffer sequence) to a target buffer (or buffer sequence).
std::size_t buffer_copy( const mutable_buffer & target, const const_buffer & source); » more... std::size_t buffer_copy( const mutable_buffer & target, const const_buffers_1 & source); » more... std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffer & source); » more... std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffers_1 & source); » more... template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffer & target, const ConstBufferSequence & source); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffer & source); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffers_1 & source); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffer & source); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffers_1 & source); » more... template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffers_1 & target, const ConstBufferSequence & source); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffer & source); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffers_1 & source); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffer & source); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffers_1 & source); » more... template< typename MutableBufferSequence, typename ConstBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const ConstBufferSequence & source); » more... std::size_t buffer_copy( const mutable_buffer & target, const const_buffer & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffer & target, const const_buffers_1 & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffer & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffers_1 & source, std::size_t max_bytes_to_copy); » more... template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffer & target, const ConstBufferSequence & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffer & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffers_1 & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffer & source, std::size_t max_bytes_to_copy); » more... std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffers_1 & source, std::size_t max_bytes_to_copy); » more... template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffers_1 & target, const ConstBufferSequence & source, std::size_t max_bytes_to_copy); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffer & source, std::size_t max_bytes_to_copy); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffers_1 & source, std::size_t max_bytes_to_copy); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffer & source, std::size_t max_bytes_to_copy); » more... template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffers_1 & source, std::size_t max_bytes_to_copy); » more... template< typename MutableBufferSequence, typename ConstBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const ConstBufferSequence & source, std::size_t max_bytes_to_copy); » more...
The buffer_copy function
is available in two forms:
buffer_copy(target, source)
buffer_copy(target, source, max_bytes_to_copy)
Both forms return the number of bytes actually copied. The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
If specified, max_bytes_to_copy.
This prevents buffer overflow, regardless of the buffer sizes used in the copy operation.
Note that buffer_copy is implemented in terms
of memcpy, and consequently
it cannot be used to copy between overlapping memory regions.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const const_buffer & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const const_buffers_1 & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffer & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffers_1 & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer sequence to a target buffer.
template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffer & target, const ConstBufferSequence & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffer & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffers_1 & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffer & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffers_1 & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer sequence to a target buffer.
template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffers_1 & target, const ConstBufferSequence & source);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffer & source);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffers_1 & source);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffer & source);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffers_1 & source);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies bytes from a source buffer sequence to a target buffer sequence.
template< typename MutableBufferSequence, typename ConstBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const ConstBufferSequence & source);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const const_buffer & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const const_buffers_1 & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffer & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffer & target, const mutable_buffers_1 & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer sequence to a target buffer.
template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffer & target, const ConstBufferSequence & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffer & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const const_buffers_1 & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffer & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer.
std::size_t buffer_copy( const mutable_buffers_1 & target, const mutable_buffers_1 & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer sequence to a target buffer.
template< typename ConstBufferSequence> std::size_t buffer_copy( const mutable_buffers_1 & target, const ConstBufferSequence & source, std::size_t max_bytes_to_copy);
A modifiable buffer representing the memory region to which the bytes will be copied.
A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffer & source, std::size_t max_bytes_to_copy);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const const_buffers_1 & source, std::size_t max_bytes_to_copy);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A non-modifiable buffer representing the memory region from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffer & source, std::size_t max_bytes_to_copy);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer to a target buffer sequence.
template< typename MutableBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const mutable_buffers_1 & source, std::size_t max_bytes_to_copy);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A modifiable buffer representing the memory region from which the bytes will be copied. The contents of the source buffer will not be modified.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
Copies a limited number of bytes from a source buffer sequence to a target buffer sequence.
template< typename MutableBufferSequence, typename ConstBufferSequence> std::size_t buffer_copy( const MutableBufferSequence & target, const ConstBufferSequence & source, std::size_t max_bytes_to_copy);
A modifiable buffer sequence representing the memory regions to which the bytes will be copied.
A non-modifiable buffer sequence representing the memory regions from which the bytes will be copied.
The maximum number of bytes to be copied.
The number of bytes copied.
The number of bytes copied is the lesser of:
buffer_size(target)
buffer_size(source)
max_bytes_to_copy
This function is implemented in terms of memcpy,
and consequently it cannot be used to copy between overlapping memory regions.
The boost::asio::buffer_size function determines the total
number of bytes in a buffer or buffer sequence.
std::size_t buffer_size( const mutable_buffer & b); » more... std::size_t buffer_size( const mutable_buffers_1 & b); » more... std::size_t buffer_size( const const_buffer & b); » more... std::size_t buffer_size( const const_buffers_1 & b); » more... template< typename BufferSequence> std::size_t buffer_size( const BufferSequence & b); » more...
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Get the number of bytes in a modifiable buffer.
std::size_t buffer_size( const mutable_buffer & b);
Get the number of bytes in a modifiable buffer.
std::size_t buffer_size( const mutable_buffers_1 & b);
Get the number of bytes in a non-modifiable buffer.
std::size_t buffer_size( const const_buffer & b);
Get the number of bytes in a non-modifiable buffer.
std::size_t buffer_size( const const_buffers_1 & b);
Get the total number of bytes in a buffer sequence.
template< typename BufferSequence> std::size_t buffer_size( const BufferSequence & b);
The BufferSequence template
parameter may meet either of the ConstBufferSequence
or MutableBufferSequence
type requirements.
Adds buffering to the read-related operations of a stream.
template< typename Stream> class buffered_read_stream : noncopyable
|
Name |
Description |
|---|---|
|
The type of the lowest layer. |
|
|
The type of the next layer. |
|
Name |
Description |
|---|---|
|
Start an asynchronous fill. |
|
|
Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. |
|
|
Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. |
|
|
Construct, passing the specified argument to initialise the next layer. |
|
|
Close the stream. |
|
|
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. |
|
|
Get the io_service associated with the object. |
|
|
Determine the amount of data that may be read without blocking. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
Get a reference to the next layer. |
|
|
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. |
|
|
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. |
|
|
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. |
|
Name |
Description |
|---|---|
|
The default buffer size. |
The buffered_read_stream class template
can be used to add buffering to the synchronous and asynchronous read operations
of a stream.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/buffered_read_stream.hpp
Convenience header: boost/asio.hpp
template< typename ReadHandler> void-or-deduced async_fill( ReadHandler handler);
Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> explicit buffered_read_stream( Arg & a); » more... template< typename Arg> buffered_read_stream( Arg & a, std::size_t buffer_size); » more...
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> buffered_read_stream( Arg & a);
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> buffered_read_stream( Arg & a, std::size_t buffer_size);
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the stream.
boost::system::error_code close( boost::system::error_code & ec);
static const std::size_t default_buffer_size = implementation_defined;
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure.
std::size_t fill(); » more...
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred.
std::size_t fill( boost::system::error_code & ec); » more...
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure.
std::size_t fill();
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred.
std::size_t fill( boost::system::error_code & ec);
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
Determine the amount of data that may be read without blocking.
std::size_t in_avail(); » more... std::size_t in_avail( boost::system::error_code & ec); » more...
Determine the amount of data that may be read without blocking.
std::size_t in_avail();
Determine the amount of data that may be read without blocking.
std::size_t in_avail( boost::system::error_code & ec);
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
typedef next_layer_type::lowest_layer_type lowest_layer_type;
Header: boost/asio/buffered_read_stream.hpp
Convenience header: boost/asio.hpp
typedef remove_reference< Stream >::type next_layer_type;
Header: boost/asio/buffered_read_stream.hpp
Convenience header: boost/asio.hpp
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers); » more...
Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers);
Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers, boost::system::error_code & ec);
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more...
Read some data from the stream. Returns the number of bytes read or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
Read some data from the stream. Returns the number of bytes read or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more...
Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
Adds buffering to the read- and write-related operations of a stream.
template< typename Stream> class buffered_stream : noncopyable
|
Name |
Description |
|---|---|
|
The type of the lowest layer. |
|
|
The type of the next layer. |
|
Name |
Description |
|---|---|
|
Start an asynchronous fill. |
|
|
Start an asynchronous flush. |
|
|
Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. |
|
|
Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. |
|
|
Construct, passing the specified argument to initialise the next layer. |
|
|
Close the stream. |
|
|
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure. Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred. |
|
|
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. |
|
|
Get the io_service associated with the object. |
|
|
Determine the amount of data that may be read without blocking. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
Get a reference to the next layer. |
|
|
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. |
|
|
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. |
|
|
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred. |
The buffered_stream
class template can be used to add buffering to the synchronous and asynchronous
read and write operations of a stream.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/buffered_stream.hpp
Convenience header: boost/asio.hpp
template< typename ReadHandler> void-or-deduced async_fill( ReadHandler handler);
template< typename WriteHandler> void-or-deduced async_flush( WriteHandler handler);
Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> explicit buffered_stream( Arg & a); » more... template< typename Arg> explicit buffered_stream( Arg & a, std::size_t read_buffer_size, std::size_t write_buffer_size); » more...
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> buffered_stream( Arg & a);
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> buffered_stream( Arg & a, std::size_t read_buffer_size, std::size_t write_buffer_size);
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the stream.
boost::system::error_code close( boost::system::error_code & ec);
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure.
std::size_t fill(); » more...
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred.
std::size_t fill( boost::system::error_code & ec); » more...
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation. Throws an exception on failure.
std::size_t fill();
Fill the buffer with some data. Returns the number of bytes placed in the buffer as a result of the operation, or 0 if an error occurred.
std::size_t fill( boost::system::error_code & ec);
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure.
std::size_t flush(); » more...
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred.
std::size_t flush( boost::system::error_code & ec); » more...
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure.
std::size_t flush();
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred.
std::size_t flush( boost::system::error_code & ec);
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
Determine the amount of data that may be read without blocking.
std::size_t in_avail(); » more... std::size_t in_avail( boost::system::error_code & ec); » more...
Determine the amount of data that may be read without blocking.
std::size_t in_avail();
Determine the amount of data that may be read without blocking.
std::size_t in_avail( boost::system::error_code & ec);
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
typedef next_layer_type::lowest_layer_type lowest_layer_type;
Header: boost/asio/buffered_stream.hpp
Convenience header: boost/asio.hpp
typedef remove_reference< Stream >::type next_layer_type;
Header: boost/asio/buffered_stream.hpp
Convenience header: boost/asio.hpp
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers); » more...
Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers);
Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers, boost::system::error_code & ec);
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more...
Read some data from the stream. Returns the number of bytes read or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
Read some data from the stream. Returns the number of bytes read or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more...
Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
Adds buffering to the write-related operations of a stream.
template< typename Stream> class buffered_write_stream : noncopyable
|
Name |
Description |
|---|---|
|
The type of the lowest layer. |
|
|
The type of the next layer. |
|
Name |
Description |
|---|---|
|
Start an asynchronous flush. |
|
|
Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation. |
|
|
Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation. |
|
|
Construct, passing the specified argument to initialise the next layer. |
|
|
Close the stream. |
|
|
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure. Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred. |
|
|
Get the io_service associated with the object. |
|
|
Determine the amount of data that may be read without blocking. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
Get a reference to the next layer. |
|
|
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure. Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred. |
|
|
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure. Read some data from the stream. Returns the number of bytes read or 0 if an error occurred. |
|
|
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure. Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw. |
|
Name |
Description |
|---|---|
|
The default buffer size. |
The buffered_write_stream class template
can be used to add buffering to the synchronous and asynchronous write operations
of a stream.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/buffered_write_stream.hpp
Convenience header: boost/asio.hpp
template< typename WriteHandler> void-or-deduced async_flush( WriteHandler handler);
Start an asynchronous read. The buffer into which the data will be read must be valid for the lifetime of the asynchronous operation.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
Start an asynchronous write. The data being written must be valid for the lifetime of the asynchronous operation.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> explicit buffered_write_stream( Arg & a); » more... template< typename Arg> buffered_write_stream( Arg & a, std::size_t buffer_size); » more...
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> buffered_write_stream( Arg & a);
Construct, passing the specified argument to initialise the next layer.
template< typename Arg> buffered_write_stream( Arg & a, std::size_t buffer_size);
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the stream.
boost::system::error_code close( boost::system::error_code & ec);
static const std::size_t default_buffer_size = implementation_defined;
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure.
std::size_t flush(); » more...
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred.
std::size_t flush( boost::system::error_code & ec); » more...
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation. Throws an exception on failure.
std::size_t flush();
Flush all data from the buffer to the next layer. Returns the number of bytes written to the next layer on the last write operation, or 0 if an error occurred.
std::size_t flush( boost::system::error_code & ec);
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
Determine the amount of data that may be read without blocking.
std::size_t in_avail(); » more... std::size_t in_avail( boost::system::error_code & ec); » more...
Determine the amount of data that may be read without blocking.
std::size_t in_avail();
Determine the amount of data that may be read without blocking.
std::size_t in_avail( boost::system::error_code & ec);
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
typedef next_layer_type::lowest_layer_type lowest_layer_type;
Header: boost/asio/buffered_write_stream.hpp
Convenience header: boost/asio.hpp
typedef remove_reference< Stream >::type next_layer_type;
Header: boost/asio/buffered_write_stream.hpp
Convenience header: boost/asio.hpp
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers); » more...
Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Peek at the incoming data on the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers);
Peek at the incoming data on the stream. Returns the number of bytes read, or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t peek( const MutableBufferSequence & buffers, boost::system::error_code & ec);
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more...
Read some data from the stream. Returns the number of bytes read or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the stream. Returns the number of bytes read. Throws an exception on failure.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
Read some data from the stream. Returns the number of bytes read or 0 if an error occurred.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more...
Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write the given data to the stream. Returns the number of bytes written. Throws an exception on failure.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
Write the given data to the stream. Returns the number of bytes written, or 0 if an error occurred and the error handler did not throw.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
Construct an iterator representing the beginning of the buffers' data.
template< typename BufferSequence> buffers_iterator< BufferSequence > buffers_begin( const BufferSequence & buffers);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Construct an iterator representing the end of the buffers' data.
template< typename BufferSequence> buffers_iterator< BufferSequence > buffers_end( const BufferSequence & buffers);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
A random access iterator over the bytes in a buffer sequence.
template< typename BufferSequence, typename ByteType = char> class buffers_iterator
|
Name |
Description |
|---|---|
|
The type used for the distance between two iterators. |
|
|
The iterator category. |
|
|
The type of the result of applying operator->() to the iterator. |
|
|
The type of the result of applying operator*() to the iterator. |
|
|
The type of the value pointed to by the iterator. |
|
Name |
Description |
|---|---|
|
Construct an iterator representing the beginning of the buffers' data. |
|
|
Default constructor. Creates an iterator in an undefined state. |
|
|
Construct an iterator representing the end of the buffers' data. |
|
|
Dereference an iterator. |
|
|
Increment operator (prefix). Increment operator (postfix). |
|
|
Addition operator. |
|
|
Decrement operator (prefix). Decrement operator (postfix). |
|
|
Subtraction operator. |
|
|
Dereference an iterator. |
|
|
Access an individual element. |
|
Name |
Description |
|---|---|
|
Test two iterators for inequality. |
|
|
Addition operator. |
|
|
Subtraction operator. |
|
|
Compare two iterators. |
|
|
Compare two iterators. |
|
|
Test two iterators for equality. |
|
|
Compare two iterators. |
|
|
Compare two iterators. |
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Construct an iterator representing the beginning of the buffers' data.
static buffers_iterator begin( const BufferSequence & buffers);
The type used for the distance between two iterators.
typedef std::ptrdiff_t difference_type;
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Construct an iterator representing the end of the buffers' data.
static buffers_iterator end( const BufferSequence & buffers);
typedef std::random_access_iterator_tag iterator_category;
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Test two iterators for inequality.
friend bool operator!=( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
friend buffers_iterator operator+( const buffers_iterator & iter, std::ptrdiff_t difference); » more... friend buffers_iterator operator+( std::ptrdiff_t difference, const buffers_iterator & iter); » more...
Addition operator.
friend buffers_iterator operator+( const buffers_iterator & iter, std::ptrdiff_t difference);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Addition operator.
friend buffers_iterator operator+( std::ptrdiff_t difference, const buffers_iterator & iter);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
buffers_iterator & operator++(); » more...
Increment operator (postfix).
buffers_iterator operator++( int ); » more...
Increment operator (prefix).
buffers_iterator & operator++();
Increment operator (postfix).
buffers_iterator operator++( int );
buffers_iterator & operator+=( std::ptrdiff_t difference);
friend buffers_iterator operator-( const buffers_iterator & iter, std::ptrdiff_t difference); » more... friend std::ptrdiff_t operator-( const buffers_iterator & a, const buffers_iterator & b); » more...
Subtraction operator.
friend buffers_iterator operator-( const buffers_iterator & iter, std::ptrdiff_t difference);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Subtraction operator.
friend std::ptrdiff_t operator-( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
buffers_iterator & operator--(); » more...
Decrement operator (postfix).
buffers_iterator operator--( int ); » more...
Decrement operator (prefix).
buffers_iterator & operator--();
Decrement operator (postfix).
buffers_iterator operator--( int );
buffers_iterator & operator-=( std::ptrdiff_t difference);
friend bool operator<( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
friend bool operator<=( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Test two iterators for equality.
friend bool operator==( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
friend bool operator>( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
friend bool operator>=( const buffers_iterator & a, const buffers_iterator & b);
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
reference operator[]( std::ptrdiff_t difference) const;
The type of the result of applying operator->()
to the iterator.
typedef const_or_non_const_ByteType * pointer;
If the buffer sequence stores buffer objects that are convertible to mutable_buffer,
this is a pointer to a non-const ByteType. Otherwise, a pointer to a const
ByteType.
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
The type of the result of applying operator*()
to the iterator.
typedef const_or_non_const_ByteType & reference;
If the buffer sequence stores buffer objects that are convertible to mutable_buffer,
this is a reference to a non-const ByteType. Otherwise, a reference to
a const ByteType.
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
The type of the value pointed to by the iterator.
typedef ByteType value_type;
Header: boost/asio/buffers_iterator.hpp
Convenience header: boost/asio.hpp
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin); » more... template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, boost::system::error_code & ec); » more... template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end); » more... template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, boost::system::error_code & ec); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition, boost::system::error_code & ec); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ConnectCondition connect_condition); » more... template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ConnectCondition connect_condition, boost::system::error_code & ec); » more...
Header: boost/asio/connect.hpp
Convenience header: boost/asio.hpp
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
Thrown on failure. If the sequence is empty, the associated error_code is boost::asio::error::not_found.
Otherwise, contains the error from the last connection attempt.
This overload assumes that a default constructed object of type Iterator represents the end of the sequence.
This is a valid assumption for iterator types such as boost::asio::ip::tcp::resolver::iterator.
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); boost::asio::connect(s, r.resolve(q));
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, boost::system::error_code & ec);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
Set to indicate what error occurred, if any. If the sequence is empty,
set to boost::asio::error::not_found. Otherwise, contains
the error from the last connection attempt.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
This overload assumes that a default constructed object of type Iterator represents the end of the sequence.
This is a valid assumption for iterator types such as boost::asio::ip::tcp::resolver::iterator.
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); boost::system::error_code ec; boost::asio::connect(s, r.resolve(q), ec); if (ec) { // An error occurred. }
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
An iterator pointing to the end of a sequence of endpoints.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
Thrown on failure. If the sequence is empty, the associated error_code is boost::asio::error::not_found.
Otherwise, contains the error from the last connection attempt.
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::resolver::iterator i = r.resolve(q), end; tcp::socket s(io_service); boost::asio::connect(s, i, end);
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, boost::system::error_code & ec);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
An iterator pointing to the end of a sequence of endpoints.
Set to indicate what error occurred, if any. If the sequence is empty,
set to boost::asio::error::not_found. Otherwise, contains
the error from the last connection attempt.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::resolver::iterator i = r.resolve(q), end; tcp::socket s(io_service); boost::system::error_code ec; boost::asio::connect(s, i, end, ec); if (ec) { // An error occurred. }
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
A function object that is called prior to each connection attempt. The signature of the function object must be:
Iterator connect_condition( const boost::system::error_code& ec, Iterator next);
The ec parameter
contains the result from the most recent connect operation. Before
the first connection attempt, ec
is always set to indicate success. The next
parameter is an iterator pointing to the next endpoint to be tried.
The function object should return the next iterator, but is permitted
to return a different iterator so that endpoints may be skipped.
The implementation guarantees that the function object will never
be called with the end iterator.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
Thrown on failure. If the sequence is empty, the associated error_code is boost::asio::error::not_found.
Otherwise, contains the error from the last connection attempt.
This overload assumes that a default constructed object of type Iterator represents the end of the sequence.
This is a valid assumption for iterator types such as boost::asio::ip::tcp::resolver::iterator.
The following connect condition function object can be used to output information about the individual connection attempts:
struct my_connect_condition { template <typename Iterator> Iterator operator()( const boost::system::error_code& ec, Iterator next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next->endpoint() << std::endl; return next; } };
It would be used with the boost::asio::connect
function as follows:
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); tcp::resolver::iterator i = boost::asio::connect( s, r.resolve(q), my_connect_condition()); std::cout << "Connected to: " << i->endpoint() << std::endl;
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, ConnectCondition connect_condition, boost::system::error_code & ec);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
A function object that is called prior to each connection attempt. The signature of the function object must be:
Iterator connect_condition( const boost::system::error_code& ec, Iterator next);
The ec parameter
contains the result from the most recent connect operation. Before
the first connection attempt, ec
is always set to indicate success. The next
parameter is an iterator pointing to the next endpoint to be tried.
The function object should return the next iterator, but is permitted
to return a different iterator so that endpoints may be skipped.
The implementation guarantees that the function object will never
be called with the end iterator.
Set to indicate what error occurred, if any. If the sequence is empty,
set to boost::asio::error::not_found. Otherwise, contains
the error from the last connection attempt.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
This overload assumes that a default constructed object of type Iterator represents the end of the sequence.
This is a valid assumption for iterator types such as boost::asio::ip::tcp::resolver::iterator.
The following connect condition function object can be used to output information about the individual connection attempts:
struct my_connect_condition { template <typename Iterator> Iterator operator()( const boost::system::error_code& ec, Iterator next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next->endpoint() << std::endl; return next; } };
It would be used with the boost::asio::connect
function as follows:
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::socket s(io_service); boost::system::error_code ec; tcp::resolver::iterator i = boost::asio::connect( s, r.resolve(q), my_connect_condition(), ec); if (ec) { // An error occurred. } else { std::cout << "Connected to: " << i->endpoint() << std::endl; }
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ConnectCondition connect_condition);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
An iterator pointing to the end of a sequence of endpoints.
A function object that is called prior to each connection attempt. The signature of the function object must be:
Iterator connect_condition( const boost::system::error_code& ec, Iterator next);
The ec parameter
contains the result from the most recent connect operation. Before
the first connection attempt, ec
is always set to indicate success. The next
parameter is an iterator pointing to the next endpoint to be tried.
The function object should return the next iterator, but is permitted
to return a different iterator so that endpoints may be skipped.
The implementation guarantees that the function object will never
be called with the end iterator.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
Thrown on failure. If the sequence is empty, the associated error_code is boost::asio::error::not_found.
Otherwise, contains the error from the last connection attempt.
The following connect condition function object can be used to output information about the individual connection attempts:
struct my_connect_condition { template <typename Iterator> Iterator operator()( const boost::system::error_code& ec, Iterator next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next->endpoint() << std::endl; return next; } };
It would be used with the boost::asio::connect
function as follows:
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::resolver::iterator i = r.resolve(q), end; tcp::socket s(io_service); i = boost::asio::connect(s, i, end, my_connect_condition()); std::cout << "Connected to: " << i->endpoint() << std::endl;
Establishes a socket connection by trying each endpoint in a sequence.
template< typename Protocol, typename SocketService, typename Iterator, typename ConnectCondition> Iterator connect( basic_socket< Protocol, SocketService > & s, Iterator begin, Iterator end, ConnectCondition connect_condition, boost::system::error_code & ec);
This function attempts to connect a socket to one of a sequence of endpoints.
It does this by repeated calls to the socket's connect
member function, once for each endpoint in the sequence, until a connection
is successfully established.
The socket to be connected. If the socket is already open, it will be closed.
An iterator pointing to the start of a sequence of endpoints.
An iterator pointing to the end of a sequence of endpoints.
A function object that is called prior to each connection attempt. The signature of the function object must be:
Iterator connect_condition( const boost::system::error_code& ec, Iterator next);
The ec parameter
contains the result from the most recent connect operation. Before
the first connection attempt, ec
is always set to indicate success. The next
parameter is an iterator pointing to the next endpoint to be tried.
The function object should return the next iterator, but is permitted
to return a different iterator so that endpoints may be skipped.
The implementation guarantees that the function object will never
be called with the end iterator.
Set to indicate what error occurred, if any. If the sequence is empty,
set to boost::asio::error::not_found. Otherwise, contains
the error from the last connection attempt.
On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator.
The following connect condition function object can be used to output information about the individual connection attempts:
struct my_connect_condition { template <typename Iterator> Iterator operator()( const boost::system::error_code& ec, Iterator next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next->endpoint() << std::endl; return next; } };
It would be used with the boost::asio::connect
function as follows:
tcp::resolver r(io_service); tcp::resolver::query q("host", "service"); tcp::resolver::iterator i = r.resolve(q), end; tcp::socket s(io_service); boost::system::error_code ec; i = boost::asio::connect(s, i, end, my_connect_condition(), ec); if (ec) { // An error occurred. } else { std::cout << "Connected to: " << i->endpoint() << std::endl; }
Holds a buffer that cannot be modified.
class const_buffer
|
Name |
Description |
|---|---|
|
Construct an empty buffer. Construct a buffer to represent a given memory range. Construct a non-modifiable buffer from a modifiable one. |
|
Name |
Description |
|---|---|
|
Create a new non-modifiable buffer that is offset from the start of another. |
The const_buffer
class provides a safe representation of a buffer that cannot be modified.
It does not own the underlying data, and so is cheap to copy or assign.
The contents of a buffer may be accessed using the buffer_size and buffer_cast functions:
boost::asio::const_buffer b1 = ...; std::size_t s1 = boost::asio::buffer_size(b1); const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
const_buffer(); » more...
Construct a buffer to represent a given memory range.
const_buffer( const void * data, std::size_t size); » more...
Construct a non-modifiable buffer from a modifiable one.
const_buffer( const mutable_buffer & b); » more...
Construct a buffer to represent a given memory range.
const_buffer( const void * data, std::size_t size);
Construct a non-modifiable buffer from a modifiable one.
const_buffer( const mutable_buffer & b);
Create a new non-modifiable buffer that is offset from the start of another.
const_buffer operator+( const const_buffer & b, std::size_t start); » more... const_buffer operator+( std::size_t start, const const_buffer & b); » more...
Create a new non-modifiable buffer that is offset from the start of another.
const_buffer operator+( const const_buffer & b, std::size_t start);
Create a new non-modifiable buffer that is offset from the start of another.
const_buffer operator+( std::size_t start, const const_buffer & b);
Adapts a single non-modifiable buffer so that it meets the requirements of the ConstBufferSequence concept.
class const_buffers_1 : public const_buffer
|
Name |
Description |
|---|---|
|
A random-access iterator type that may be used to read elements. |
|
|
The type for each element in the list of buffers. |
|
Name |
Description |
|---|---|
|
Get a random-access iterator to the first element. |
|
|
Construct to represent a given memory range. Construct to represent a single non-modifiable buffer. |
|
|
Get a random-access iterator for one past the last element. |
|
Name |
Description |
|---|---|
|
Create a new non-modifiable buffer that is offset from the start of another. |
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Construct to represent a given memory range.
const_buffers_1( const void * data, std::size_t size); » more...
Construct to represent a single non-modifiable buffer.
explicit const_buffers_1( const const_buffer & b); » more...
Construct to represent a given memory range.
const_buffers_1( const void * data, std::size_t size);
Construct to represent a single non-modifiable buffer.
const_buffers_1( const const_buffer & b);
A random-access iterator type that may be used to read elements.
typedef const const_buffer * const_iterator;
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Create a new non-modifiable buffer that is offset from the start of another.
const_buffer operator+( const const_buffer & b, std::size_t start); » more... const_buffer operator+( std::size_t start, const const_buffer & b); » more...
Inherited from const_buffer.
Create a new non-modifiable buffer that is offset from the start of another.
const_buffer operator+( const const_buffer & b, std::size_t start);
Inherited from const_buffer.
Create a new non-modifiable buffer that is offset from the start of another.
const_buffer operator+( std::size_t start, const const_buffer & b);
The type for each element in the list of buffers.
typedef const_buffer value_type;
|
Name |
Description |
|---|---|
|
Construct an empty buffer. Construct a buffer to represent a given memory range. Construct a non-modifiable buffer from a modifiable one. |
|
Name |
Description |
|---|---|
|
Create a new non-modifiable buffer that is offset from the start of another. |
The const_buffer
class provides a safe representation of a buffer that cannot be modified.
It does not own the underlying data, and so is cheap to copy or assign.
The contents of a buffer may be accessed using the buffer_size and buffer_cast functions:
boost::asio::const_buffer b1 = ...; std::size_t s1 = boost::asio::buffer_size(b1); const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Provides support for implementing stackless coroutines.
class coroutine
|
Name |
Description |
|---|---|
|
Constructs a coroutine in its initial state. |
|
|
Returns true if the coroutine is the child of a fork. |
|
|
Returns true if the coroutine has reached its terminal state. |
|
|
Returns true if the coroutine is the parent of a fork. |
The coroutine class may be
used to implement stackless coroutines. The class itself is used to store
the current state of the coroutine.
Coroutines are copy-constructible and assignable, and the space overhead is a single int. They can be used as a base class:
class session : coroutine { ... };
or as a data member:
class session { ... coroutine coro_; };
or even bound in as a function argument using lambdas or bind(). The important thing is that as the application
maintains a copy of the object for as long as the coroutine must be kept
alive.
A coroutine is used in conjunction with certain "pseudo-keywords", which are implemented as macros. These macros are defined by a header file:
#include <boost/asio/yield.hpp>
and may conversely be undefined as follows:
#include <boost/asio/unyield.hpp>
reenter
The reenter macro is used
to define the body of a coroutine. It takes a single argument: a pointer
or reference to a coroutine object. For example, if the base class is a coroutine
object you may write:
reenter (this) { ... coroutine body ... }
and if a data member or other variable you can write:
reenter (coro_) { ... coroutine body ... }
When reenter is executed
at runtime, control jumps to the location of the last yield
or fork.
The coroutine body may also be a single statement, such as:
reenter (this) for (;;) { ... }
Limitation: The reenter
macro is implemented using a switch. This means that you must take care when
using local variables within the coroutine body. The local variable is not
allowed in a position where reentering the coroutine could bypass the variable
definition.
yield statement
This form of the yield keyword
is often used with asynchronous operations:
yield socket_->async_read_some(buffer(*buffer_), *this);
This divides into four logical steps:
yield saves the current
state of the coroutine.
When the asynchronous operation completes, the function object is invoked
and reenter causes control
to transfer to the resume point. It is important to remember to carry the
coroutine state forward with the asynchronous operation. In the above snippet,
the current class is a function object object with a coroutine object as
base class or data member.
The statement may also be a compound statement, and this permits us to define local variables with limited scope:
yield { mutable_buffers_1 b = buffer(*buffer_); socket_->async_read_some(b, *this); }
yield return expression ;
This form of yield is often
used in generators or coroutine-based parsers. For example, the function
object:
struct interleave : coroutine { istream& is1; istream& is2; char operator()(char c) { reenter (this) for (;;) { yield return is1.get(); yield return is2.get(); } } };
defines a trivial coroutine that interleaves the characters from two input streams.
This type of yield divides
into three logical steps:
yield saves the current
state of the coroutine.
yield ;
This form of yield is equivalent
to the following steps:
yield saves the current
state of the coroutine.
This form might be applied when coroutines are used for cooperative threading and scheduling is explicitly managed. For example:
struct task : coroutine { ... void operator()() { reenter (this) { while (... not finished ...) { ... do something ... yield; ... do some more ... yield; } } } ... }; ... task t1, t2; for (;;) { t1(); t2(); }
yield break ;
The final form of yield is
used to explicitly terminate the coroutine. This form is comprised of two
steps:
yield sets the coroutine
state to indicate termination.
Once terminated, calls to is_complete() return true and the coroutine cannot be
reentered.
Note that a coroutine may also be implicitly terminated if the coroutine body is exited without a yield, e.g. by return, throw or by running to the end of the body.
fork statement
The fork pseudo-keyword is
used when "forking" a coroutine, i.e. splitting it into two (or
more) copies. One use of fork
is in a server, where a new coroutine is created to handle each client connection:
reenter (this) { do { socket_.reset(new tcp::socket(io_service_)); yield acceptor->async_accept(*socket_, *this); fork server(*this)(); } while (is_parent()); ... client-specific handling follows ... }
The logical steps involved in a fork
are:
fork saves the current
state of the coroutine.
The functions is_parent()
and is_child()
can be used to differentiate between parent and child. You would use these
functions to alter subsequent control flow.
Note that fork doesn't do
the actual forking by itself. It is the application's responsibility to create
a clone of the coroutine and call it. The clone can be called immediately,
as above, or scheduled for delayed execution using something like io_service::post().
If preferred, an application can use macro names that follow a more typical naming convention, rather than the pseudo-keywords. These are:
BOOST_ASIO_CORO_REENTER
instead of reenter
BOOST_ASIO_CORO_YIELD
instead of yield
BOOST_ASIO_CORO_FORK
instead of fork
Header: boost/asio/coroutine.hpp
Convenience header: boost/asio.hpp
Default service implementation for a datagram socket.
template< typename Protocol> class datagram_socket_service : public io_service::service
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The type of a datagram socket. |
|
|
The native socket type. |
|
|
(Deprecated: Use native_handle_type.) The native socket type. |
|
|
The protocol type. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to a datagram socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous receive that will get the endpoint of the sender. |
|
|
Start an asynchronous send. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close a datagram socket implementation. |
|
|
Connect the datagram socket to the specified endpoint. |
|
|
Construct a new datagram socket implementation. |
|
|
Move-construct a new datagram socket implementation from another protocol type. |
|
|
Construct a new datagram socket service for the specified io_service. |
|
|
Destroy a datagram socket implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Get a socket option. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint. |
|
|
Move-assign from another datagram socket implementation. |
|
|
Move-construct a new datagram socket implementation. |
|
|
(Deprecated: Use native_handle().) Get the native socket implementation. |
|
|
Get the native socket implementation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Receive some data from the peer. |
|
|
Receive a datagram with the endpoint of the sender. |
|
|
Get the remote endpoint. |
|
|
Send the given data to the peer. |
|
|
Send a datagram to the specified endpoint. |
|
|
Set a socket option. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/datagram_socket_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to a datagram socket.
boost::system::error_code assign( implementation_type & impl, const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, ConnectHandler handler);
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler);
Start an asynchronous receive that will get the endpoint of the sender.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( implementation_type & impl, const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( implementation_type & impl, const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, WriteHandler handler);
Determine whether the socket is at the out-of-band data mark.
bool at_mark( const implementation_type & impl, boost::system::error_code & ec) const;
Determine the number of bytes available for reading.
std::size_t available( const implementation_type & impl, boost::system::error_code & ec) const;
boost::system::error_code bind( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec);
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a datagram socket implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Connect the datagram socket to the specified endpoint.
boost::system::error_code connect( implementation_type & impl, const endpoint_type & peer_endpoint, boost::system::error_code & ec);
Move-construct a new datagram socket implementation from another protocol type.
template< typename Protocol1> void converting_move_construct( implementation_type & impl, typename datagram_socket_service< Protocol1 >::implementation_type & other_impl, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
Construct a new datagram
socket service for the specified io_service.
datagram_socket_service( boost::asio::io_service & io_service);
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/datagram_socket_service.hpp
Convenience header: boost/asio.hpp
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
template< typename GettableSocketOption> boost::system::error_code get_option( const implementation_type & impl, GettableSocketOption & option, boost::system::error_code & ec) const;
The type of a datagram socket.
typedef implementation_defined implementation_type;
Header: boost/asio/datagram_socket_service.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( implementation_type & impl, IoControlCommand & command, boost::system::error_code & ec);
endpoint_type local_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Move-assign from another datagram socket implementation.
void move_assign( implementation_type & impl, datagram_socket_service & other_service, implementation_type & other_impl);
Move-construct a new datagram socket implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native socket implementation.
native_type native( implementation_type & impl);
Get the native socket implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/datagram_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
(Deprecated: Use native_handle_type.) The native socket type.
typedef implementation_defined native_type;
Header: boost/asio/datagram_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
boost::system::error_code open( implementation_type & impl, const protocol_type & protocol, boost::system::error_code & ec);
typedef Protocol protocol_type;
Header: boost/asio/datagram_socket_service.hpp
Convenience header: boost/asio.hpp
Receive some data from the peer.
template< typename MutableBufferSequence> std::size_t receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
Receive a datagram with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( implementation_type & impl, const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, boost::system::error_code & ec);
endpoint_type remote_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Send the given data to the peer.
template< typename ConstBufferSequence> std::size_t send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
Send a datagram to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( implementation_type & impl, const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, boost::system::error_code & ec);
template< typename SettableSocketOption> boost::system::error_code set_option( implementation_type & impl, const SettableSocketOption & option, boost::system::error_code & ec);
Typedef for the typical usage of timer. Uses a UTC clock.
typedef basic_deadline_timer< boost::posix_time::ptime > deadline_timer;
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
The time type. |
|
|
The time traits type. |
|
Name |
Description |
|---|---|
|
Start an asynchronous wait on the timer. |
|
|
Constructor. Constructor to set a particular expiry time as an absolute time. Constructor to set a particular expiry time relative to now. |
|
|
Cancel any asynchronous operations that are waiting on the timer. |
|
|
Cancels one asynchronous operation that is waiting on the timer. |
|
|
Get the timer's expiry time as an absolute time. Set the timer's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the timer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Perform a blocking wait on the timer. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_deadline_timer class template
provides the ability to perform a blocking or asynchronous wait for a timer
to expire.
A deadline timer is always in one of two states: "expired" or "not
expired". If the wait() or async_wait() function is called on an expired timer,
the wait operation will complete immediately.
Most applications will use the deadline_timer typedef.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing a blocking wait:
// Construct a timer without setting an expiry time. boost::asio::deadline_timer timer(io_service); // Set an expiry time relative to now. timer.expires_from_now(boost::posix_time::seconds(5)); // Wait for the timer to expire. timer.wait();
Performing an asynchronous wait:
void handler(const boost::system::error_code& error) { if (!error) { // Timer expired. } } ... // Construct a timer with an absolute expiry time. boost::asio::deadline_timer timer(io_service, boost::posix_time::time_from_string("2005-12-07 23:59:59.000")); // Start an asynchronous wait. timer.async_wait(handler);
Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
void on_some_event() { if (my_timer.expires_from_now(seconds(5)) > 0) { // We managed to cancel the timer. Start new asynchronous wait. my_timer.async_wait(on_timeout); } else { // Too late, timer has already expired! } } void on_timeout(const boost::system::error_code& e) { if (e != boost::asio::error::operation_aborted) { // Timer was not cancelled, take necessary action. } }
boost::asio::basic_deadline_timer::expires_from_now()
function cancels any pending asynchronous waits, and returns the number
of asynchronous waits that were cancelled. If it returns 0 then you were
too late and the wait handler has already been executed, or will soon
be executed. If it returns 1 then the wait handler was successfully cancelled.
boost::asio::error::operation_aborted.
Header: boost/asio/deadline_timer.hpp
Convenience header: boost/asio.hpp
Default service implementation for a timer.
template< typename TimeType, typename TimeTraits = boost::asio::time_traits<TimeType>> class deadline_timer_service : public io_service::service
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The implementation type of the deadline timer. |
|
|
The time type. |
|
|
The time traits type. |
|
Name |
Description |
|---|---|
|
Cancel any asynchronous wait operations associated with the timer. |
|
|
Cancels one asynchronous wait operation associated with the timer. |
|
|
Construct a new timer implementation. |
|
|
Construct a new timer service for the specified io_service. |
|
|
Destroy a timer implementation. |
|
|
Get the expiry time for the timer as an absolute time. Set the expiry time for the timer as an absolute time. |
|
|
Get the expiry time for the timer relative to now. Set the expiry time for the timer relative to now. |
|
|
Get the io_service object that owns the service. |
|
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/deadline_timer_service.hpp
Convenience header: boost/asio.hpp
template< typename WaitHandler> void-or-deduced async_wait( implementation_type & impl, WaitHandler handler);
Cancel any asynchronous wait operations associated with the timer.
std::size_t cancel( implementation_type & impl, boost::system::error_code & ec);
Cancels one asynchronous wait operation associated with the timer.
std::size_t cancel_one( implementation_type & impl, boost::system::error_code & ec);
Construct a new timer service
for the specified io_service.
deadline_timer_service( boost::asio::io_service & io_service);
typedef traits_type::duration_type duration_type;
Header: boost/asio/deadline_timer_service.hpp
Convenience header: boost/asio.hpp
Get the expiry time for the timer as an absolute time.
time_type expires_at( const implementation_type & impl) const; » more...
Set the expiry time for the timer as an absolute time.
std::size_t expires_at( implementation_type & impl, const time_type & expiry_time, boost::system::error_code & ec); » more...
Get the expiry time for the timer as an absolute time.
time_type expires_at( const implementation_type & impl) const;
Set the expiry time for the timer as an absolute time.
std::size_t expires_at( implementation_type & impl, const time_type & expiry_time, boost::system::error_code & ec);
Get the expiry time for the timer relative to now.
duration_type expires_from_now( const implementation_type & impl) const; » more...
Set the expiry time for the timer relative to now.
std::size_t expires_from_now( implementation_type & impl, const duration_type & expiry_time, boost::system::error_code & ec); » more...
Get the expiry time for the timer relative to now.
duration_type expires_from_now( const implementation_type & impl) const;
Set the expiry time for the timer relative to now.
std::size_t expires_from_now( implementation_type & impl, const duration_type & expiry_time, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The implementation type of the deadline timer.
typedef implementation_defined implementation_type;
Header: boost/asio/deadline_timer_service.hpp
Convenience header: boost/asio.hpp
typedef traits_type::time_type time_type;
Header: boost/asio/deadline_timer_service.hpp
Convenience header: boost/asio.hpp
typedef TimeTraits traits_type;
Header: boost/asio/deadline_timer_service.hpp
Convenience header: boost/asio.hpp
void wait( implementation_type & impl, boost::system::error_code & ec);
static const boost::system::error_category & addrinfo_category = boost::asio::error::get_addrinfo_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
enum addrinfo_errors
The service is not supported for the given socket type.
The socket type is not supported.
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
enum basic_errors
Permission denied.
Address family not supported by protocol.
Address already in use.
Transport endpoint is already connected.
Operation already in progress.
Broken pipe.
A connection has been aborted.
Connection refused.
Connection reset by peer.
Bad file descriptor.
Bad address.
No route to host.
Operation now in progress.
Interrupted system call.
Invalid argument.
Message too long.
The name was too long.
Network is down.
Network dropped connection on reset.
Network is unreachable.
Too many open files.
No buffer space available.
Cannot allocate memory.
Operation not permitted.
Protocol not available.
No such device.
Transport endpoint is not connected.
Socket operation on non-socket.
Operation cancelled.
Operation not supported.
Cannot send after transport endpoint shutdown.
Connection timed out.
Resource temporarily unavailable.
The socket is marked non-blocking and the requested operation would block.
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
const boost::system::error_category & get_addrinfo_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
const boost::system::error_category & get_misc_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
const boost::system::error_category & get_netdb_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
const boost::system::error_category & get_ssl_category();
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
const boost::system::error_category & get_system_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
boost::system::error_code make_error_code( basic_errors e); » more... boost::system::error_code make_error_code( netdb_errors e); » more... boost::system::error_code make_error_code( addrinfo_errors e); » more... boost::system::error_code make_error_code( misc_errors e); » more... boost::system::error_code make_error_code( ssl_errors e); » more...
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
boost::system::error_code make_error_code( basic_errors e);
boost::system::error_code make_error_code( netdb_errors e);
boost::system::error_code make_error_code( addrinfo_errors e);
boost::system::error_code make_error_code( misc_errors e);
boost::system::error_code make_error_code( ssl_errors e);
static const boost::system::error_category & misc_category = boost::asio::error::get_misc_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
enum misc_errors
Already open.
End of file or stream.
Element not found.
The descriptor cannot fit into the select system call's fd_set.
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
static const boost::system::error_category & netdb_category = boost::asio::error::get_netdb_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
enum netdb_errors
Host not found (authoritative).
Host not found (non-authoritative).
The query is valid but does not have associated address data.
A non-recoverable error occurred.
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
static const boost::system::error_category & ssl_category = boost::asio::error::get_ssl_category();
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
enum ssl_errors
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
static const boost::system::error_category & system_category = boost::asio::error::get_system_category();
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
Describes an endpoint for any socket type.
template< typename Protocol> class basic_endpoint
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint from the specified socket address. Construct an endpoint from the specific endpoint type. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
The generic::basic_endpoint class template describes
an endpoint that may be associated with any socket type.
The socket types sockaddr type must be able to fit into a sockaddr_storage
structure.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
basic_endpoint(); » more...
Construct an endpoint from the specified socket address.
basic_endpoint( const void * socket_address, std::size_t socket_address_size, int socket_protocol = 0); » more...
Construct an endpoint from the specific endpoint type.
template< typename Endpoint> basic_endpoint( const Endpoint & endpoint); » more...
Copy constructor.
basic_endpoint( const basic_endpoint & other); » more...
Construct an endpoint from the specified socket address.
basic_endpoint( const void * socket_address, std::size_t socket_address_size, int socket_protocol = 0);
Construct an endpoint from the specific endpoint type.
template< typename Endpoint> basic_endpoint( const Endpoint & endpoint);
Copy constructor.
basic_endpoint( const basic_endpoint & other);
Get the underlying endpoint in the native type.
data_type * data(); » more... const data_type * data() const; » more...
Get the underlying endpoint in the native type.
data_type * data();
Get the underlying endpoint in the native type.
const data_type * data() const;
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer.
typedef implementation_defined data_type;
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare two endpoints for inequality.
friend bool operator!=( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator<( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator<=( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
basic_endpoint & operator=( const basic_endpoint & other);
Compare two endpoints for equality.
friend bool operator==( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator>( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator>=( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
The protocol type associated with the endpoint.
typedef Protocol protocol_type;
Header: boost/asio/generic/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Encapsulates the flags needed for a generic datagram-oriented socket.
class datagram_protocol
|
Name |
Description |
|---|---|
|
Construct a protocol object for a specific address family and protocol. Construct a generic protocol object from a specific protocol. |
|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The generic::datagram_protocol class contains
flags necessary for datagram-oriented sockets of any address family and protocol.
Constructing using a native address family and socket protocol:
datagram_protocol p(AF_INET, IPPROTO_UDP);
Constructing from a specific protocol type:
datagram_protocol p(boost::asio::ip::udp::v4());
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/generic/datagram_protocol.hpp
Convenience header: boost/asio.hpp
Construct a protocol object for a specific address family and protocol.
datagram_protocol( int address_family, int socket_protocol); » more...
Construct a generic protocol object from a specific protocol.
template< typename Protocol> datagram_protocol( const Protocol & source_protocol); » more...
Construct a protocol object for a specific address family and protocol.
datagram_protocol( int address_family, int socket_protocol);
Construct a generic protocol object from a specific protocol.
template< typename Protocol> datagram_protocol( const Protocol & source_protocol);
bad_cast Thrown if the source protocol is not datagram-oriented.
typedef basic_endpoint< datagram_protocol > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint from the specified socket address. Construct an endpoint from the specific endpoint type. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
The generic::basic_endpoint class template
describes an endpoint that may be associated with any socket type.
The socket types sockaddr type must be able to fit into a sockaddr_storage structure.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/datagram_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const datagram_protocol & p1, const datagram_protocol & p2);
Header: boost/asio/generic/datagram_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const datagram_protocol & p1, const datagram_protocol & p2);
Header: boost/asio/generic/datagram_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_datagram_socket< datagram_protocol > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_datagram_socket without opening it. Construct and open a basic_datagram_socket. Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. Construct a basic_datagram_socket on an existing native socket. Move-construct a basic_datagram_socket from another. Move-construct a basic_datagram_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_datagram_socket from another. Move-assign a basic_datagram_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive a datagram with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send a datagram to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_datagram_socket class template
provides asynchronous and blocking datagram-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/datagram_protocol.hpp
Convenience header: boost/asio.hpp
Encapsulates the flags needed for a generic raw socket.
class raw_protocol
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Construct a protocol object for a specific address family and protocol. Construct a generic protocol object from a specific protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The generic::raw_protocol class contains flags
necessary for raw sockets of any address family and protocol.
Constructing using a native address family and socket protocol:
raw_protocol p(AF_INET, IPPROTO_ICMP);
Constructing from a specific protocol type:
raw_protocol p(boost::asio::ip::icmp::v4());
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/generic/raw_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_endpoint< raw_protocol > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint from the specified socket address. Construct an endpoint from the specific endpoint type. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
The generic::basic_endpoint class template
describes an endpoint that may be associated with any socket type.
The socket types sockaddr type must be able to fit into a sockaddr_storage structure.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/raw_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const raw_protocol & p1, const raw_protocol & p2);
Header: boost/asio/generic/raw_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const raw_protocol & p1, const raw_protocol & p2);
Header: boost/asio/generic/raw_protocol.hpp
Convenience header: boost/asio.hpp
Construct a protocol object for a specific address family and protocol.
raw_protocol( int address_family, int socket_protocol); » more...
Construct a generic protocol object from a specific protocol.
template< typename Protocol> raw_protocol( const Protocol & source_protocol); » more...
Construct a protocol object for a specific address family and protocol.
raw_protocol( int address_family, int socket_protocol);
Construct a generic protocol object from a specific protocol.
template< typename Protocol> raw_protocol( const Protocol & source_protocol);
bad_cast Thrown if the source protocol is not raw-oriented.
typedef basic_raw_socket< raw_protocol > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_raw_socket without opening it. Construct and open a basic_raw_socket. Construct a basic_raw_socket, opening it and binding it to the given local endpoint. Construct a basic_raw_socket on an existing native socket. Move-construct a basic_raw_socket from another. Move-construct a basic_raw_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_raw_socket from another. Move-assign a basic_raw_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive raw data with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send raw data to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_raw_socket class template
provides asynchronous and blocking raw-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/raw_protocol.hpp
Convenience header: boost/asio.hpp
Encapsulates the flags needed for a generic sequenced packet socket.
class seq_packet_protocol
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Construct a protocol object for a specific address family and protocol. Construct a generic protocol object from a specific protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The generic::seq_packet_protocol class contains
flags necessary for seq_packet-oriented sockets of any address family and
protocol.
Constructing using a native address family and socket protocol:
seq_packet_protocol p(AF_INET, IPPROTO_SCTP);
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/generic/seq_packet_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_endpoint< seq_packet_protocol > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint from the specified socket address. Construct an endpoint from the specific endpoint type. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
The generic::basic_endpoint class template
describes an endpoint that may be associated with any socket type.
The socket types sockaddr type must be able to fit into a sockaddr_storage structure.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/seq_packet_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const seq_packet_protocol & p1, const seq_packet_protocol & p2);
Header: boost/asio/generic/seq_packet_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const seq_packet_protocol & p1, const seq_packet_protocol & p2);
Header: boost/asio/generic/seq_packet_protocol.hpp
Convenience header: boost/asio.hpp
Construct a protocol object for a specific address family and protocol.
seq_packet_protocol( int address_family, int socket_protocol); » more...
Construct a generic protocol object from a specific protocol.
template< typename Protocol> seq_packet_protocol( const Protocol & source_protocol); » more...
Construct a protocol object for a specific address family and protocol.
seq_packet_protocol( int address_family, int socket_protocol);
Construct a generic protocol object from a specific protocol.
template< typename Protocol> seq_packet_protocol( const Protocol & source_protocol);
bad_cast Thrown if the source protocol is not based around sequenced packets.
typedef basic_seq_packet_socket< seq_packet_protocol > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_seq_packet_socket without opening it. Construct and open a basic_seq_packet_socket. Construct a basic_seq_packet_socket, opening it and binding it to the given local endpoint. Construct a basic_seq_packet_socket on an existing native socket. Move-construct a basic_seq_packet_socket from another. Move-construct a basic_seq_packet_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_seq_packet_socket from another. Move-assign a basic_seq_packet_socket from a socket of another protocol type. |
|
|
Receive some data on the socket. Receive some data on a connected socket. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_seq_packet_socket class
template provides asynchronous and blocking sequenced packet socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/seq_packet_protocol.hpp
Convenience header: boost/asio.hpp
Encapsulates the flags needed for a generic stream-oriented socket.
class stream_protocol
|
Name |
Description |
|---|---|
|
The type of an endpoint. |
|
|
The generic socket iostream type. |
|
|
The generic socket type. |
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Construct a protocol object for a specific address family and protocol. Construct a generic protocol object from a specific protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The generic::stream_protocol class contains flags
necessary for stream-oriented sockets of any address family and protocol.
Constructing using a native address family and socket protocol:
stream_protocol p(AF_INET, IPPROTO_TCP);
Constructing from a specific protocol type:
stream_protocol p(boost::asio::ip::tcp::v4());
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/generic/stream_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_endpoint< stream_protocol > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint from the specified socket address. Construct an endpoint from the specific endpoint type. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
The generic::basic_endpoint class template
describes an endpoint that may be associated with any socket type.
The socket types sockaddr type must be able to fit into a sockaddr_storage structure.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/stream_protocol.hpp
Convenience header: boost/asio.hpp
The generic socket iostream type.
typedef basic_socket_iostream< stream_protocol > iostream;
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The endpoint type. |
|
|
The time type. |
|
Name |
Description |
|---|---|
|
Construct a basic_socket_iostream without establishing a connection. Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Close the connection. |
|
|
Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Get the last error associated with the stream. |
|
|
Get the stream's expiry time as an absolute time. Set the stream's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the stream's expiry time relative to now. |
|
|
Return a pointer to the underlying streambuf. |
Header: boost/asio/generic/stream_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const stream_protocol & p1, const stream_protocol & p2);
Header: boost/asio/generic/stream_protocol.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const stream_protocol & p1, const stream_protocol & p2);
Header: boost/asio/generic/stream_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_stream_socket< stream_protocol > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Start an asynchronous write. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_stream_socket without opening it. Construct and open a basic_stream_socket. Construct a basic_stream_socket, opening it and binding it to the given local endpoint. Construct a basic_stream_socket on an existing native socket. Move-construct a basic_stream_socket from another. Move-construct a basic_stream_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_stream_socket from another. Move-assign a basic_stream_socket from a socket of another protocol type. |
|
|
Read some data from the socket. |
|
|
Receive some data on the socket. Receive some data on a connected socket. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
|
Write some data to the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_stream_socket class template
provides asynchronous and blocking stream-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/generic/stream_protocol.hpp
Convenience header: boost/asio.hpp
Construct a protocol object for a specific address family and protocol.
stream_protocol( int address_family, int socket_protocol); » more...
Construct a generic protocol object from a specific protocol.
template< typename Protocol> stream_protocol( const Protocol & source_protocol); » more...
Construct a protocol object for a specific address family and protocol.
stream_protocol( int address_family, int socket_protocol);
Construct a generic protocol object from a specific protocol.
template< typename Protocol> stream_protocol( const Protocol & source_protocol);
bad_cast Thrown if the source protocol is not stream-oriented.
Default handler type traits provided for all handlers.
template< typename Handler, typename Signature> struct handler_type
|
Name |
Description |
|---|---|
|
The handler type for the specific signature. |
The handler_type
traits class is used for determining the concrete handler type to be used
for an asynchronous operation. It allows the handler type to be determined
at the point where the specific completion handler signature is known.
This template may be specialised for user-defined handler types.
Header: boost/asio/handler_type.hpp
Convenience header: boost/asio.hpp
The handler type for the specific signature.
typedef Handler type;
Header: boost/asio/handler_type.hpp
Convenience header: boost/asio.hpp
template< typename Service> bool has_service( io_service & ios);
This function is used to determine whether the io_service contains a service object
corresponding to the given service type.
The io_service
object that owns the service.
A boolean indicating whether the io_service contains the service.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Typedef for a timer based on the high resolution clock.
typedef basic_waitable_timer< chrono::high_resolution_clock > high_resolution_timer;
|
Name |
Description |
|---|---|
|
The clock type. |
|
|
The duration type of the clock. |
|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
The time point type of the clock. |
|
|
The wait traits type. |
|
Name |
Description |
|---|---|
|
Start an asynchronous wait on the timer. |
|
|
Constructor. Constructor to set a particular expiry time as an absolute time. Constructor to set a particular expiry time relative to now. |
|
|
Cancel any asynchronous operations that are waiting on the timer. |
|
|
Cancels one asynchronous operation that is waiting on the timer. |
|
|
Get the timer's expiry time as an absolute time. Set the timer's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the timer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Perform a blocking wait on the timer. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_waitable_timer class template
provides the ability to perform a blocking or asynchronous wait for a timer
to expire.
A waitable timer is always in one of two states: "expired" or "not
expired". If the wait() or async_wait() function is called on an expired timer,
the wait operation will complete immediately.
Most applications will use one of the steady_timer, system_timer or high_resolution_timer typedefs.
This waitable timer functionality is for use with the C++11 standard library's
<chrono> facility, or with the Boost.Chrono library.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing a blocking wait (C++11):
// Construct a timer without setting an expiry time. boost::asio::steady_timer timer(io_service); // Set an expiry time relative to now. timer.expires_from_now(std::chrono::seconds(5)); // Wait for the timer to expire. timer.wait();
Performing an asynchronous wait (C++11):
void handler(const boost::system::error_code& error) { if (!error) { // Timer expired. } } ... // Construct a timer with an absolute expiry time. boost::asio::steady_timer timer(io_service, std::chrono::steady_clock::now() + std::chrono::seconds(60)); // Start an asynchronous wait. timer.async_wait(handler);
Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
void on_some_event() { if (my_timer.expires_from_now(seconds(5)) > 0) { // We managed to cancel the timer. Start new asynchronous wait. my_timer.async_wait(on_timeout); } else { // Too late, timer has already expired! } } void on_timeout(const boost::system::error_code& e) { if (e != boost::asio::error::operation_aborted) { // Timer was not cancelled, take necessary action. } }
boost::asio::basic_waitable_timer::expires_from_now()
function cancels any pending asynchronous waits, and returns the number
of asynchronous waits that were cancelled. If it returns 0 then you were
too late and the wait handler has already been executed, or will soon
be executed. If it returns 1 then the wait handler was successfully cancelled.
boost::asio::error::operation_aborted.
This typedef uses the C++11 <chrono>
standard library facility, if available. Otherwise, it may use the Boost.Chrono
library. To explicitly utilise Boost.Chrono, use the basic_waitable_timer template directly:
typedef basic_waitable_timer<boost::chrono::high_resolution_clock> timer;
Header: boost/asio/high_resolution_timer.hpp
Convenience header: None
Exception thrown when trying to add a service object to an io_service where the service has
a different owner.
class invalid_service_owner
|
Name |
Description |
|---|---|
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Provides core I/O functionality.
class io_service : noncopyable
|
Name |
Description |
|---|---|
|
Class used to uniquely identify a service. |
|
|
Base class for all io_service services. |
|
|
Provides serialised handler execution. |
|
|
Class to inform the io_service when it has work to do. |
|
|
Fork-related event notifications. |
|
Name |
Description |
|---|---|
|
Request the io_service to invoke the given handler. |
|
|
Constructor. |
|
|
Notify the io_service of a fork-related event. |
|
|
Run the io_service object's event processing loop to execute ready handlers. |
|
|
Run the io_service object's event processing loop to execute one ready handler. |
|
|
Request the io_service to invoke the given handler and return immediately. |
|
|
Reset the io_service in preparation for a subsequent run() invocation. |
|
|
Run the io_service object's event processing loop. |
|
|
Run the io_service object's event processing loop to execute at most one handler. |
|
|
Stop the io_service object's event processing loop. |
|
|
Determine whether the io_service object has been stopped. |
|
|
Create a new handler that automatically dispatches the wrapped handler on the io_service. |
|
|
Destructor. |
|
Name |
Description |
|---|---|
|
Add a service object to the io_service. |
|
|
Determine if an io_service contains a specified service type. |
|
|
Obtain the service object corresponding to the given type. |
The io_service
class provides the core I/O functionality for users of the asynchronous I/O
objects, including:
boost::asio::ip::tcp::socket
boost::asio::ip::tcp::acceptor
boost::asio::ip::udp::socket
deadline_timer.
The io_service
class also includes facilities intended for developers of custom asynchronous
services.
Distinct objects: Safe.
Shared objects: Safe, with the
specific exceptions of the reset() and notify_fork() functions. Calling reset() while there are unfinished run(),
run_one(),
poll()
or poll_one()
calls results in undefined behaviour. The notify_fork() function should not be called while any
io_service
function, or any function on an I/O object that is associated with the io_service,
is being called in another thread.
Synchronous operations on I/O objects implicitly run the io_service object for an individual
operation. The io_service functions run(),
run_one(),
poll()
or poll_one()
must be called for the io_service to perform asynchronous
operations on behalf of a C++ program. Notification that an asynchronous
operation has completed is delivered by invocation of the associated handler.
Handlers are invoked only by a thread that is currently calling any overload
of run(),
run_one(),
poll()
or poll_one()
for the io_service.
If an exception is thrown from a handler, the exception is allowed to propagate
through the throwing thread's invocation of run(), run_one(), poll() or poll_one(). No other threads that are calling any
of these functions are affected. It is then the responsibility of the application
to catch the exception.
After the exception has been caught, the run(), run_one(), poll() or poll_one() call may be restarted without
the need for an intervening call to reset(). This allows the thread to rejoin the
io_service
object's thread pool without impacting any other threads in the pool.
For example:
boost::asio::io_service io_service; ... for (;;) { try { io_service.run(); break; // run() exited normally } catch (my_exception& e) { // Deal with exception as appropriate. } }
Some applications may need to prevent an io_service object's run() call
from returning when there is no more work to do. For example, the io_service may be being run in a
background thread that is launched prior to the application's asynchronous
operations. The run()
call may be kept running by creating an object of type io_service::work:
boost::asio::io_service io_service; boost::asio::io_service::work work(io_service); ...
To effect a shutdown, the application will then need to call the io_service object's stop()
member function. This will cause the io_service run() call to return as soon as possible, abandoning
unfinished operations and without permitting ready handlers to be dispatched.
Alternatively, if the application requires that all operations and handlers be allowed to finish normally, the work object may be explicitly destroyed.
boost::asio::io_service io_service; auto_ptr<boost::asio::io_service::work> work( new boost::asio::io_service::work(io_service)); ... work.reset(); // Allow run() to exit.
Class io_service
implements an extensible, type-safe, polymorphic set of I/O services, indexed
by service type. An object of class io_service must be initialised before
I/O objects such as sockets, resolvers and timers can be used. These I/O
objects are distinguished by having constructors that accept an io_service&
parameter.
I/O services exist to manage the logical interface to the operating system on behalf of the I/O objects. In particular, there are resources that are shared across a class of I/O objects. For example, timers may be implemented in terms of a single timer queue. The I/O services manage these shared resources.
Access to the services of an io_service is via three function
templates, use_service(),
add_service()
and has_service().
In a call to use_service<Service>(), the type argument chooses a service,
making available all members of the named type. If Service
is not present in an io_service, an object of type Service is created and added to the io_service.
A C++ program can check if an io_service implements a particular
service with the function template has_service<Service>().
Service objects may be explicitly added to an io_service using the function template
add_service<Service>().
If the Service is already
present, the service_already_exists exception
is thrown. If the owner of the service is not the same object as the io_service
parameter, the invalid_service_owner exception
is thrown.
Once a service reference is obtained from an io_service object by calling use_service(),
that reference remains usable as long as the owning io_service object exists.
All I/O service implementations have io_service::service as a public base class.
Custom I/O services may be implemented by deriving from this class and then
added to an io_service using the facilities
described above.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Add a service object to the io_service.
template< typename Service> friend void add_service( io_service & ios, Service * svc);
This function is used to add a service to the io_service.
The io_service object that owns
the service.
The service object. On success, ownership of the service object is
transferred to the io_service. When the io_service
object is destroyed, it will destroy the service object by performing:
delete static_cast<io_service::service*>(svc)
Thrown if a service of the given type is already present in the
io_service.
Thrown if the service's owning io_service is not the io_service
object specified by the ios parameter.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Request the io_service to invoke the given
handler.
template< typename CompletionHandler> void-or-deduced dispatch( CompletionHandler handler);
This function is used to ask the io_service to execute the given
handler.
The io_service
guarantees that the handler will only be called in a thread in which the
run(),
run_one(),
poll()
or poll_one()
member functions is currently being invoked. The handler may be executed
inside this function if the guarantee can be met.
The handler to be called. The io_service will make a copy
of the handler object as required. The function signature of the
handler must be:
void handler();
This function throws an exception only if:
asio_handler_allocate
function; or
throws an exception.
Fork-related event notifications.
enum fork_event
Notify the io_service that the process is about to fork.
Notify the io_service that the process has forked and is the parent.
Notify the io_service that the process has forked and is the child.
Determine if an io_service contains a specified
service type.
template< typename Service> friend bool has_service( io_service & ios);
This function is used to determine whether the io_service contains a service
object corresponding to the given service type.
The io_service object that owns
the service.
A boolean indicating whether the io_service contains the service.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
io_service(); » more... explicit io_service( std::size_t concurrency_hint); » more...
Constructor.
io_service( std::size_t concurrency_hint);
Construct with a hint about the required level of concurrency.
A suggestion to the implementation on how many threads it should allow to run simultaneously.
Notify the io_service of a fork-related event.
void notify_fork( boost::asio::io_service::fork_event event);
This function is used to inform the io_service that the process is
about to fork, or has just forked. This allows the io_service, and the services it
contains, to perform any necessary housekeeping to ensure correct operation
following a fork.
This function must not be called while any other io_service function, or any function
on an I/O object associated with the io_service, is being called in
another thread. It is, however, safe to call this function from within
a completion handler, provided no other thread is accessing the io_service.
A fork-related event.
Thrown on failure. If the notification fails the io_service object should
no longer be used and should be destroyed.
The following code illustrates how to incorporate the notify_fork() function:
my_io_service.notify_fork(boost::asio::io_service::fork_prepare); if (fork() == 0) { // This is the child process. my_io_service.notify_fork(boost::asio::io_service::fork_child); } else { // This is the parent process. my_io_service.notify_fork(boost::asio::io_service::fork_parent); }
For each service object svc
in the io_service
set, performs svc->fork_service();.
When processing the fork_prepare event, services are visited in reverse
order of the beginning of service object lifetime. Otherwise, services
are visited in order of the beginning of service object lifetime.
Run the io_service object's event processing
loop to execute ready handlers.
std::size_t poll(); » more... std::size_t poll( boost::system::error_code & ec); » more...
Run the io_service object's event processing
loop to execute ready handlers.
std::size_t poll();
The poll()
function runs handlers that are ready to run, without blocking, until
the io_service
has been stopped or there are no more ready handlers.
The number of handlers that were executed.
Thrown on failure.
Run the io_service object's event processing
loop to execute ready handlers.
std::size_t poll( boost::system::error_code & ec);
The poll()
function runs handlers that are ready to run, without blocking, until
the io_service
has been stopped or there are no more ready handlers.
Set to indicate what error occurred, if any.
The number of handlers that were executed.
Run the io_service object's event processing
loop to execute one ready handler.
std::size_t poll_one(); » more... std::size_t poll_one( boost::system::error_code & ec); » more...
Run the io_service object's event processing
loop to execute one ready handler.
std::size_t poll_one();
The poll_one()
function runs at most one handler that is ready to run, without blocking.
The number of handlers that were executed.
Thrown on failure.
Run the io_service object's event processing
loop to execute one ready handler.
std::size_t poll_one( boost::system::error_code & ec);
The poll_one()
function runs at most one handler that is ready to run, without blocking.
Set to indicate what error occurred, if any.
The number of handlers that were executed.
Request the io_service to invoke the given
handler and return immediately.
template< typename CompletionHandler> void-or-deduced post( CompletionHandler handler);
This function is used to ask the io_service to execute the given
handler, but without allowing the io_service to call the handler
from inside this function.
The io_service
guarantees that the handler will only be called in a thread in which the
run(),
run_one(),
poll()
or poll_one()
member functions is currently being invoked.
The handler to be called. The io_service will make a copy
of the handler object as required. The function signature of the
handler must be:
void handler();
This function throws an exception only if:
asio_handler_allocate
function; or
throws an exception.
Reset the io_service in preparation for
a subsequent run()
invocation.
void reset();
This function must be called prior to any second or later set of invocations
of the run(),
run_one(),
poll()
or poll_one()
functions when a previous invocation of these functions returned due to
the io_service
being stopped or running out of work. After a call to reset(), the io_service object's stopped()
function will return false.
This function must not be called while there are any unfinished calls to
the run(),
run_one(),
poll()
or poll_one()
functions.
Run the io_service object's event processing
loop.
std::size_t run(); » more... std::size_t run( boost::system::error_code & ec); » more...
Run the io_service object's event processing
loop.
std::size_t run();
The run()
function blocks until all work has finished and there are no more handlers
to be dispatched, or until the io_service has been stopped.
Multiple threads may call the run() function to set up a pool of threads
from which the io_service may execute handlers.
All threads that are waiting in the pool are equivalent and the io_service
may choose any one of them to invoke a handler.
A normal exit from the run() function implies that the io_service object is stopped
(the stopped()
function returns true).
Subsequent calls to run(), run_one(), poll() or poll_one() will return immediately unless there
is a prior call to reset().
The number of handlers that were executed.
Thrown on failure.
The run()
function must not be called from a thread that is currently calling one
of run(),
run_one(),
poll()
or poll_one()
on the same io_service object.
The poll()
function may also be used to dispatch ready handlers, but without blocking.
Run the io_service object's event processing
loop.
std::size_t run( boost::system::error_code & ec);
The run()
function blocks until all work has finished and there are no more handlers
to be dispatched, or until the io_service has been stopped.
Multiple threads may call the run() function to set up a pool of threads
from which the io_service may execute handlers.
All threads that are waiting in the pool are equivalent and the io_service
may choose any one of them to invoke a handler.
A normal exit from the run() function implies that the io_service object is stopped
(the stopped()
function returns true).
Subsequent calls to run(), run_one(), poll() or poll_one() will return immediately unless there
is a prior call to reset().
Set to indicate what error occurred, if any.
The number of handlers that were executed.
The run()
function must not be called from a thread that is currently calling one
of run(),
run_one(),
poll()
or poll_one()
on the same io_service object.
The poll()
function may also be used to dispatch ready handlers, but without blocking.
Run the io_service object's event processing
loop to execute at most one handler.
std::size_t run_one(); » more... std::size_t run_one( boost::system::error_code & ec); » more...
Run the io_service object's event processing
loop to execute at most one handler.
std::size_t run_one();
The run_one()
function blocks until one handler has been dispatched, or until the
io_service
has been stopped.
The number of handlers that were executed. A zero return value implies
that the io_service object is stopped
(the stopped()
function returns true).
Subsequent calls to run(), run_one(), poll() or poll_one() will return immediately unless there
is a prior call to reset().
Thrown on failure.
Run the io_service object's event processing
loop to execute at most one handler.
std::size_t run_one( boost::system::error_code & ec);
The run_one()
function blocks until one handler has been dispatched, or until the
io_service
has been stopped.
The number of handlers that were executed. A zero return value implies
that the io_service object is stopped
(the stopped()
function returns true).
Subsequent calls to run(), run_one(), poll() or poll_one() will return immediately unless there
is a prior call to reset().
The number of handlers that were executed.
Stop the io_service object's event processing
loop.
void stop();
This function does not block, but instead simply signals the io_service to stop. All invocations
of its run()
or run_one()
member functions should return as soon as possible. Subsequent calls to
run(),
run_one(),
poll()
or poll_one()
will return immediately until reset() is called.
Determine whether the io_service object has been stopped.
bool stopped() const;
This function is used to determine whether an io_service object has been stopped,
either through an explicit call to stop(), or due to running out of work. When
an io_service
object is stopped, calls to run(), run_one(), poll() or poll_one() will return immediately without invoking
any handlers.
true if the io_service object is stopped,
otherwise false.
Obtain the service object corresponding to the given type.
template< typename Service> friend Service & use_service( io_service & ios);
This function is used to locate a service object that corresponds to the
given service type. If there is no existing implementation of the service,
then the io_service will create a new instance
of the service.
The io_service object that owns
the service.
The service interface implementing the specified service type. Ownership of the service interface is not transferred to the caller.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Create a new handler that automatically dispatches the wrapped
handler on the io_service.
template< typename Handler> unspecified wrap( Handler handler);
This function is used to create a new handler function object that, when
invoked, will automatically pass the wrapped handler to the io_service object's dispatch function.
The handler to be wrapped. The io_service will make a copy
of the handler object as required. The function signature of the
handler must be:
void handler(A1 a1, ... An an);
A function object that, when invoked, passes the wrapped handler to the
io_service
object's dispatch function. Given a function object with the signature:
R f(A1 a1, ... An an);
If this function object is passed to the wrap function like so:
io_service.wrap(f);
then the return value is a function object with the signature
void g(A1 a1, ... An an);
that, when invoked, executes code equivalent to:
io_service.dispatch(boost::bind(f, a1, ... an));
~io_service();
On destruction, the io_service performs the following
sequence of operations:
svc
in the io_service set, in reverse
order of the beginning of service object lifetime, performs svc->shutdown_service().
io_service, or any associated
strand, are destroyed.
svc
in the io_service set, in reverse
order of the beginning of service object lifetime, performs delete static_cast<io_service::service*>(svc).
The destruction sequence described above permits programs to simplify their
resource management by using shared_ptr<>. Where an object's lifetime is
tied to the lifetime of a connection (or some other sequence of asynchronous
operations), a shared_ptr
to the object would be bound into the handlers for all asynchronous operations
associated with it. This works as follows:
shared_ptr references
to the objects are destroyed.
io_service function stop()
is called to terminate any run() calls as soon as possible. The io_service
destructor defined above destroys all handlers, causing all shared_ptr references to all connection
objects to be destroyed.
Class used to uniquely identify a service.
class id : noncopyable
|
Name |
Description |
|---|---|
|
Constructor. |
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Base class for all io_service services.
class service : noncopyable
|
Name |
Description |
|---|---|
|
Get the io_service object that owns the service. |
|
Name |
Description |
|---|---|
|
Handle notification of a fork-related event to perform any necessary housekeeping. |
|
|
Destroy all user-defined handler objects owned by the service. |
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
service( boost::asio::io_service & owner);
The io_service object that owns
the service.
Handle notification of a fork-related event to perform any necessary housekeeping.
virtual void fork_service( boost::asio::io_service::fork_event event);
This function is not a pure virtual so that services only have to implement it if necessary. The default implementation does nothing.
Provides serialised handler execution.
class strand
|
Name |
Description |
|---|---|
|
Request the strand to invoke the given handler. |
|
|
Get the io_service associated with the strand. |
|
|
Request the strand to invoke the given handler and return immediately. |
|
|
Determine whether the strand is running in the current thread. |
|
|
Constructor. |
|
|
Create a new handler that automatically dispatches the wrapped handler on the strand. |
|
|
Destructor. |
The io_service::strand class provides the ability
to post and dispatch handlers with the guarantee that none of those handlers
will execute concurrently.
Given:
s
a meeting completion
handler requirements
a1 which is
an arbitrary copy of a
made by the implementation
b meeting completion
handler requirements
b1 which is
an arbitrary copy of b
made by the implementation
if any of the following conditions are true:
s.post(a)
happens-before s.post(b)
s.post(a)
happens-before s.dispatch(b),
where the latter is performed outside the strand
s.dispatch(a)
happens-before s.post(b),
where the former is performed outside the strand
s.dispatch(a)
happens-before s.dispatch(b),
where both are performed outside the strand
then asio_handler_invoke(a1,
&a1) happens-before asio_handler_invoke(b1,
&b1).
Note that in the following case:
async_op_1(..., s.wrap(a)); async_op_2(..., s.wrap(b));
the completion of the first async operation will perform s.dispatch(a),
and the second will perform s.dispatch(b),
but the order in which those are performed is unspecified. That is, you cannot
state whether one happens-before the other. Therefore none of the above conditions
are met and no ordering guarantee is made.
The implementation makes no guarantee that handlers posted or dispatched
through different strand
objects will be invoked concurrently.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/strand.hpp
Convenience header: boost/asio.hpp
Request the strand to invoke the given handler.
template< typename CompletionHandler> void-or-deduced dispatch( CompletionHandler handler);
This function is used to ask the strand to execute the given handler.
The strand object guarantees that handlers posted or dispatched through the strand will not be executed concurrently. The handler may be executed inside this function if the guarantee can be met. If this function is called from within a handler that was posted or dispatched through the same strand, then the new handler will be executed immediately.
The strand's guarantee is in addition to the guarantee provided by the
underlying io_service. The io_service guarantees that the
handler will only be called in a thread in which the io_service's run member
function is currently being invoked.
The handler to be called. The strand will make a copy of the handler object as required. The function signature of the handler must be:
void handler();
Get the io_service associated with the
strand.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the strand
uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the strand
will use to dispatch handlers. Ownership is not transferred to the caller.
Request the strand to invoke the given handler and return immediately.
template< typename CompletionHandler> void-or-deduced post( CompletionHandler handler);
This function is used to ask the strand to execute the given handler, but without allowing the strand to call the handler from inside this function.
The strand object guarantees that handlers posted or dispatched through
the strand will not be executed concurrently. The strand's guarantee is
in addition to the guarantee provided by the underlying io_service. The io_service guarantees that the
handler will only be called in a thread in which the io_service's run member
function is currently being invoked.
The handler to be called. The strand will make a copy of the handler object as required. The function signature of the handler must be:
void handler();
Determine whether the strand is running in the current thread.
bool running_in_this_thread() const;
true if the current thread
is executing a handler that was submitted to the strand using post(),
dispatch()
or wrap().
Otherwise returns false.
strand( boost::asio::io_service & io_service);
Constructs the strand.
The io_service object that the
strand will use to dispatch handlers that are ready to be run.
Create a new handler that automatically dispatches the wrapped handler on the strand.
template< typename Handler> unspecified wrap( Handler handler);
This function is used to create a new handler function object that, when invoked, will automatically pass the wrapped handler to the strand's dispatch function.
The handler to be wrapped. The strand will make a copy of the handler object as required. The function signature of the handler must be:
void handler(A1 a1, ... An an);
A function object that, when invoked, passes the wrapped handler to the strand's dispatch function. Given a function object with the signature:
R f(A1 a1, ... An an);
If this function object is passed to the wrap function like so:
strand.wrap(f);
then the return value is a function object with the signature
void g(A1 a1, ... An an);
that, when invoked, executes code equivalent to:
strand.dispatch(boost::bind(f, a1, ... an));
~strand();
Destroys a strand.
Handlers posted through the strand that have not yet been invoked will still be dispatched in a way that meets the guarantee of non-concurrency.
Class to inform the io_service when it has work to do.
class work
|
Name |
Description |
|---|---|
|
Get the io_service associated with the work. |
|
|
Constructor notifies the io_service that work is starting. Copy constructor notifies the io_service that work is starting. |
|
|
Destructor notifies the io_service that the work is complete. |
The work class is used to inform the io_service when work starts and
finishes. This ensures that the io_service object's run() function
will not exit while work is underway, and that it does exit when there is
no unfinished work remaining.
The work class is copy-constructible so that it may be used as a data member in a handler class. It is not assignable.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Get the io_service associated with the
work.
boost::asio::io_service & get_io_service();
Constructor notifies the io_service that work is starting.
explicit work( boost::asio::io_service & io_service); » more...
Copy constructor notifies the io_service that work is starting.
work( const work & other); » more...
Constructor notifies the io_service that work is starting.
work( boost::asio::io_service & io_service);
The constructor is used to inform the io_service that some work has
begun. This ensures that the io_service object's run()
function will not exit while the work is underway.
Copy constructor notifies the io_service that work is starting.
work( const work & other);
The constructor is used to inform the io_service that some work has
begun. This ensures that the io_service object's run()
function will not exit while the work is underway.
Destructor notifies the io_service that the work is complete.
~work();
The destructor is used to inform the io_service that some work has
finished. Once the count of unfinished work reaches zero, the io_service object's run()
function is permitted to exit.
Implements version-independent IP addresses.
class address
|
Name |
Description |
|---|---|
|
Default constructor. Construct an address from an IPv4 address. Construct an address from an IPv6 address. Copy constructor. |
|
|
Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation. |
|
|
Determine whether the address is a loopback address. |
|
|
Determine whether the address is a multicast address. |
|
|
Determine whether the address is unspecified. |
|
|
Get whether the address is an IP version 4 address. |
|
|
Get whether the address is an IP version 6 address. |
|
|
Assign from another address. Assign from an IPv4 address. Assign from an IPv6 address. |
|
|
Get the address as a string in dotted decimal format. |
|
|
Get the address as an IP version 4 address. |
|
|
Get the address as an IP version 6 address. |
|
Name |
Description |
|---|---|
|
Compare two addresses for inequality. |
|
|
Compare addresses for ordering. |
|
|
Compare addresses for ordering. |
|
|
Compare two addresses for equality. |
|
|
Compare addresses for ordering. |
|
|
Compare addresses for ordering. |
|
Name |
Description |
|---|---|
|
Output an address as a string. |
The ip::address
class provides the ability to use either IP version 4 or version 6 addresses.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
address(); » more...
Construct an address from an IPv4 address.
address( const boost::asio::ip::address_v4 & ipv4_address); » more...
Construct an address from an IPv6 address.
address( const boost::asio::ip::address_v6 & ipv6_address); » more...
Copy constructor.
address( const address & other); » more...
Construct an address from an IPv4 address.
address( const boost::asio::ip::address_v4 & ipv4_address);
Construct an address from an IPv6 address.
address( const boost::asio::ip::address_v6 & ipv6_address);
Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation.
static address from_string( const char * str); » more... static address from_string( const char * str, boost::system::error_code & ec); » more... static address from_string( const std::string & str); » more... static address from_string( const std::string & str, boost::system::error_code & ec); » more...
Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation.
static address from_string( const char * str);
Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation.
static address from_string( const char * str, boost::system::error_code & ec);
Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation.
static address from_string( const std::string & str);
Create an address from an IPv4 address string in dotted decimal form, or from an IPv6 address in hexadecimal notation.
static address from_string( const std::string & str, boost::system::error_code & ec);
Compare two addresses for inequality.
friend bool operator!=( const address & a1, const address & a2);
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator<( const address & a1, const address & a2);
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
Output an address as a string.
template< typename Elem, typename Traits> std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const address & addr);
Used to output a human-readable string for a specified address.
The output stream to which the string will be written.
The address to be written.
The output stream.
Compare addresses for ordering.
friend bool operator<=( const address & a1, const address & a2);
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
address & operator=( const address & other); » more...
Assign from an IPv4 address.
address & operator=( const boost::asio::ip::address_v4 & ipv4_address); » more...
Assign from an IPv6 address.
address & operator=( const boost::asio::ip::address_v6 & ipv6_address); » more...
Assign from another address.
address & operator=( const address & other);
Assign from an IPv4 address.
address & operator=( const boost::asio::ip::address_v4 & ipv4_address);
Assign from an IPv6 address.
address & operator=( const boost::asio::ip::address_v6 & ipv6_address);
Compare two addresses for equality.
friend bool operator==( const address & a1, const address & a2);
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator>( const address & a1, const address & a2);
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator>=( const address & a1, const address & a2);
Header: boost/asio/ip/address.hpp
Convenience header: boost/asio.hpp
Get the address as a string in dotted decimal format.
std::string to_string() const; » more... std::string to_string( boost::system::error_code & ec) const; » more...
Get the address as a string in dotted decimal format.
std::string to_string() const;
Get the address as a string in dotted decimal format.
std::string to_string( boost::system::error_code & ec) const;
Implements IP version 4 style addresses.
class address_v4
|
Name |
Description |
|---|---|
|
The type used to represent an address as an array of bytes. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an address from raw bytes. Construct an address from a unsigned long in host byte order. Copy constructor. |
|
|
Obtain an address object that represents any address. |
|
|
Obtain an address object that represents the broadcast address. Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask. |
|
|
Create an address from an IP address string in dotted decimal form. |
|
|
Determine whether the address is a class A address. |
|
|
Determine whether the address is a class B address. |
|
|
Determine whether the address is a class C address. |
|
|
Determine whether the address is a loopback address. |
|
|
Determine whether the address is a multicast address. |
|
|
Determine whether the address is unspecified. |
|
|
Obtain an address object that represents the loopback address. |
|
|
Obtain the netmask that corresponds to the address, based on its address class. |
|
|
Assign from another address. |
|
|
Get the address in bytes, in network byte order. |
|
|
Get the address as a string in dotted decimal format. |
|
|
Get the address as an unsigned long in host byte order. |
|
Name |
Description |
|---|---|
|
Compare two addresses for inequality. |
|
|
Compare addresses for ordering. |
|
|
Compare addresses for ordering. |
|
|
Compare two addresses for equality. |
|
|
Compare addresses for ordering. |
|
|
Compare addresses for ordering. |
|
Name |
Description |
|---|---|
|
Output an address as a string. |
The ip::address_v4
class provides the ability to use and manipulate IP version 4 addresses.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
address_v4(); » more...
Construct an address from raw bytes.
explicit address_v4( const bytes_type & bytes); » more...
Construct an address from a unsigned long in host byte order.
explicit address_v4( unsigned long addr); » more...
Copy constructor.
address_v4( const address_v4 & other); » more...
Construct an address from raw bytes.
address_v4( const bytes_type & bytes);
Construct an address from a unsigned long in host byte order.
address_v4( unsigned long addr);
Copy constructor.
address_v4( const address_v4 & other);
Obtain an address object that represents the broadcast address.
static address_v4 broadcast(); » more...
Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask.
static address_v4 broadcast( const address_v4 & addr, const address_v4 & mask); » more...
Obtain an address object that represents the broadcast address.
static address_v4 broadcast();
Obtain an address object that represents the broadcast address that corresponds to the specified address and netmask.
static address_v4 broadcast( const address_v4 & addr, const address_v4 & mask);
The type used to represent an address as an array of bytes.
typedef array< unsigned char, 4 > bytes_type;
This type is defined in terms of the C++0x template std::array
when it is available. Otherwise, it uses boost:array.
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
Create an address from an IP address string in dotted decimal form.
static address_v4 from_string( const char * str); » more... static address_v4 from_string( const char * str, boost::system::error_code & ec); » more... static address_v4 from_string( const std::string & str); » more... static address_v4 from_string( const std::string & str, boost::system::error_code & ec); » more...
Create an address from an IP address string in dotted decimal form.
static address_v4 from_string( const char * str);
Create an address from an IP address string in dotted decimal form.
static address_v4 from_string( const char * str, boost::system::error_code & ec);
Create an address from an IP address string in dotted decimal form.
static address_v4 from_string( const std::string & str);
Create an address from an IP address string in dotted decimal form.
static address_v4 from_string( const std::string & str, boost::system::error_code & ec);
Obtain the netmask that corresponds to the address, based on its address class.
static address_v4 netmask( const address_v4 & addr);
Compare two addresses for inequality.
friend bool operator!=( const address_v4 & a1, const address_v4 & a2);
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator<( const address_v4 & a1, const address_v4 & a2);
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
Output an address as a string.
template< typename Elem, typename Traits> std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const address_v4 & addr);
Used to output a human-readable string for a specified address.
The output stream to which the string will be written.
The address to be written.
The output stream.
Compare addresses for ordering.
friend bool operator<=( const address_v4 & a1, const address_v4 & a2);
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
address_v4 & operator=( const address_v4 & other);
Compare two addresses for equality.
friend bool operator==( const address_v4 & a1, const address_v4 & a2);
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator>( const address_v4 & a1, const address_v4 & a2);
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator>=( const address_v4 & a1, const address_v4 & a2);
Header: boost/asio/ip/address_v4.hpp
Convenience header: boost/asio.hpp
Get the address as a string in dotted decimal format.
std::string to_string() const; » more... std::string to_string( boost::system::error_code & ec) const; » more...
Get the address as a string in dotted decimal format.
std::string to_string() const;
Get the address as a string in dotted decimal format.
std::string to_string( boost::system::error_code & ec) const;
Implements IP version 6 style addresses.
class address_v6
|
Name |
Description |
|---|---|
|
The type used to represent an address as an array of bytes. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an address from raw bytes and scope ID. Copy constructor. |
|
|
Obtain an address object that represents any address. |
|
|
Create an address from an IP address string. |
|
|
Determine whether the address is link local. |
|
|
Determine whether the address is a loopback address. |
|
|
Determine whether the address is a multicast address. |
|
|
Determine whether the address is a global multicast address. |
|
|
Determine whether the address is a link-local multicast address. |
|
|
Determine whether the address is a node-local multicast address. |
|
|
Determine whether the address is a org-local multicast address. |
|
|
Determine whether the address is a site-local multicast address. |
|
|
Determine whether the address is site local. |
|
|
Determine whether the address is unspecified. |
|
|
Determine whether the address is an IPv4-compatible address. |
|
|
Determine whether the address is a mapped IPv4 address. |
|
|
Obtain an address object that represents the loopback address. |
|
|
Assign from another address. |
|
|
The scope ID of the address. |
|
|
Get the address in bytes, in network byte order. |
|
|
Get the address as a string. |
|
|
Converts an IPv4-mapped or IPv4-compatible address to an IPv4 address. |
|
|
Create an IPv4-compatible IPv6 address. |
|
|
Create an IPv4-mapped IPv6 address. |
|
Name |
Description |
|---|---|
|
Compare two addresses for inequality. |
|
|
Compare addresses for ordering. |
|
|
Compare addresses for ordering. |
|
|
Compare two addresses for equality. |
|
|
Compare addresses for ordering. |
|
|
Compare addresses for ordering. |
|
Name |
Description |
|---|---|
|
Output an address as a string. |
The ip::address_v6
class provides the ability to use and manipulate IP version 6 addresses.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
address_v6(); » more...
Construct an address from raw bytes and scope ID.
explicit address_v6( const bytes_type & bytes, unsigned long scope_id = 0); » more...
Copy constructor.
address_v6( const address_v6 & other); » more...
Construct an address from raw bytes and scope ID.
address_v6( const bytes_type & bytes, unsigned long scope_id = 0);
Copy constructor.
address_v6( const address_v6 & other);
The type used to represent an address as an array of bytes.
typedef array< unsigned char, 16 > bytes_type;
This type is defined in terms of the C++0x template std::array
when it is available. Otherwise, it uses boost:array.
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
Create an address from an IP address string.
static address_v6 from_string( const char * str); » more... static address_v6 from_string( const char * str, boost::system::error_code & ec); » more... static address_v6 from_string( const std::string & str); » more... static address_v6 from_string( const std::string & str, boost::system::error_code & ec); » more...
Create an address from an IP address string.
static address_v6 from_string( const char * str);
Create an address from an IP address string.
static address_v6 from_string( const char * str, boost::system::error_code & ec);
Create an address from an IP address string.
static address_v6 from_string( const std::string & str);
Create an address from an IP address string.
static address_v6 from_string( const std::string & str, boost::system::error_code & ec);
Determine whether the address is a link-local multicast address.
bool is_multicast_link_local() const;
Determine whether the address is a node-local multicast address.
bool is_multicast_node_local() const;
Determine whether the address is a org-local multicast address.
bool is_multicast_org_local() const;
Determine whether the address is a site-local multicast address.
bool is_multicast_site_local() const;
Compare two addresses for inequality.
friend bool operator!=( const address_v6 & a1, const address_v6 & a2);
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator<( const address_v6 & a1, const address_v6 & a2);
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
Output an address as a string.
template< typename Elem, typename Traits> std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const address_v6 & addr);
Used to output a human-readable string for a specified address.
The output stream to which the string will be written.
The address to be written.
The output stream.
Compare addresses for ordering.
friend bool operator<=( const address_v6 & a1, const address_v6 & a2);
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
address_v6 & operator=( const address_v6 & other);
Compare two addresses for equality.
friend bool operator==( const address_v6 & a1, const address_v6 & a2);
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator>( const address_v6 & a1, const address_v6 & a2);
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
Compare addresses for ordering.
friend bool operator>=( const address_v6 & a1, const address_v6 & a2);
Header: boost/asio/ip/address_v6.hpp
Convenience header: boost/asio.hpp
unsigned long scope_id() const; » more... void scope_id( unsigned long id); » more...
The scope ID of the address.
unsigned long scope_id() const;
Returns the scope ID associated with the IPv6 address.
The scope ID of the address.
void scope_id( unsigned long id);
Modifies the scope ID associated with the IPv6 address.
std::string to_string() const; » more... std::string to_string( boost::system::error_code & ec) const; » more...
Get the address as a string.
std::string to_string() const;
Get the address as a string.
std::string to_string( boost::system::error_code & ec) const;
Describes an endpoint for a version-independent IP socket.
template< typename InternetProtocol> class basic_endpoint
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Get the IP address associated with the endpoint. Set the IP address associated with the endpoint. |
|
|
Default constructor. Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the port associated with the endpoint. The port number is always in the host's byte order. Set the port associated with the endpoint. The port number is always in the host's byte order. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The ip::basic_endpoint
class template describes an endpoint that may be associated with a particular
socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Get the IP address associated with the endpoint.
boost::asio::ip::address address() const; » more...
Set the IP address associated with the endpoint.
void address( const boost::asio::ip::address & addr); » more...
Get the IP address associated with the endpoint.
boost::asio::ip::address address() const;
Set the IP address associated with the endpoint.
void address( const boost::asio::ip::address & addr);
basic_endpoint(); » more...
Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections.
basic_endpoint( const InternetProtocol & internet_protocol, unsigned short port_num); » more...
Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint.
basic_endpoint( const boost::asio::ip::address & addr, unsigned short port_num); » more...
Copy constructor.
basic_endpoint( const basic_endpoint & other); » more...
Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections.
basic_endpoint( const InternetProtocol & internet_protocol, unsigned short port_num);
To initialise an IPv4 TCP endpoint for port 1234, use:
boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), 1234);
To specify an IPv6 UDP endpoint for port 9876, use:
boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);
Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint.
basic_endpoint( const boost::asio::ip::address & addr, unsigned short port_num);
Copy constructor.
basic_endpoint( const basic_endpoint & other);
Get the underlying endpoint in the native type.
data_type * data(); » more... const data_type * data() const; » more...
Get the underlying endpoint in the native type.
data_type * data();
Get the underlying endpoint in the native type.
const data_type * data() const;
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer.
typedef implementation_defined data_type;
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare two endpoints for inequality.
friend bool operator!=( const basic_endpoint< InternetProtocol > & e1, const basic_endpoint< InternetProtocol > & e2);
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator<( const basic_endpoint< InternetProtocol > & e1, const basic_endpoint< InternetProtocol > & e2);
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Output an endpoint as a string.
std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const basic_endpoint< InternetProtocol > & endpoint);
Used to output a human-readable string for a specified endpoint.
The output stream to which the string will be written.
The endpoint to be written.
The output stream.
Compare endpoints for ordering.
friend bool operator<=( const basic_endpoint< InternetProtocol > & e1, const basic_endpoint< InternetProtocol > & e2);
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
basic_endpoint & operator=( const basic_endpoint & other);
Compare two endpoints for equality.
friend bool operator==( const basic_endpoint< InternetProtocol > & e1, const basic_endpoint< InternetProtocol > & e2);
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator>( const basic_endpoint< InternetProtocol > & e1, const basic_endpoint< InternetProtocol > & e2);
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator>=( const basic_endpoint< InternetProtocol > & e1, const basic_endpoint< InternetProtocol > & e2);
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Get the port associated with the endpoint. The port number is always in the host's byte order.
unsigned short port() const; » more...
Set the port associated with the endpoint. The port number is always in the host's byte order.
void port( unsigned short port_num); » more...
Get the port associated with the endpoint. The port number is always in the host's byte order.
unsigned short port() const;
Set the port associated with the endpoint. The port number is always in the host's byte order.
void port( unsigned short port_num);
The protocol type associated with the endpoint.
typedef InternetProtocol protocol_type;
Header: boost/asio/ip/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Provides endpoint resolution functionality.
template< typename InternetProtocol, typename ResolverService = resolver_service<InternetProtocol>> class basic_resolver : public basic_io_object< ResolverService >
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
The iterator type. |
|
|
The protocol type. |
|
|
The query type. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Asynchronously perform forward resolution of a query to a list of entries. Asynchronously perform reverse resolution of an endpoint to a list of entries. |
|
|
Constructor. |
|
|
Cancel any asynchronous operations that are waiting on the resolver. |
|
|
Get the io_service associated with the object. |
|
|
Perform forward resolution of a query to a list of entries. Perform reverse resolution of an endpoint to a list of entries. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The ip::basic_resolver
class template provides the ability to resolve a query to a list of endpoints.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
Asynchronously perform forward resolution of a query to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( const query & q, ResolveHandler handler); » more...
Asynchronously perform reverse resolution of an endpoint to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( const endpoint_type & e, ResolveHandler handler); » more...
Asynchronously perform forward resolution of a query to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( const query & q, ResolveHandler handler);
This function is used to asynchronously resolve a query into a list of endpoint entries.
A query object that determines what endpoints will be returned.
The handler to be called when the resolve operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. resolver::iterator iterator // Forward-only iterator that can // be used to traverse the list // of endpoint entries. );
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().
A default constructed iterator represents the end of the list.
A successful resolve operation is guaranteed to pass at least one entry to the handler.
Asynchronously perform reverse resolution of an endpoint to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( const endpoint_type & e, ResolveHandler handler);
This function is used to asynchronously resolve an endpoint into a list of endpoint entries.
An endpoint object that determines what endpoints will be returned.
The handler to be called when the resolve operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. resolver::iterator iterator // Forward-only iterator that can // be used to traverse the list // of endpoint entries. );
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().
A default constructed iterator represents the end of the list.
A successful resolve operation is guaranteed to pass at least one entry to the handler.
basic_resolver( boost::asio::io_service & io_service);
This constructor creates a ip::basic_resolver.
The io_service object that the
resolver will use to dispatch handlers for any asynchronous operations
performed on the timer.
Cancel any asynchronous operations that are waiting on the resolver.
void cancel();
This function forces the completion of any pending asynchronous operations
on the host resolver. The handler for each cancelled operation will be
invoked with the boost::asio::error::operation_aborted
error code.
typedef InternetProtocol::endpoint endpoint_type;
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver_iterator< InternetProtocol > iterator;
|
Name |
Description |
|---|---|
|
The type used for the distance between two iterators. |
|
|
The iterator category. |
|
|
The type of the result of applying operator->() to the iterator. |
|
|
The type of the result of applying operator*() to the iterator. |
|
|
The type of the value pointed to by the iterator. |
|
Name |
Description |
|---|---|
|
Default constructor creates an end iterator. |
|
|
Create an iterator from an addrinfo list returned by getaddrinfo. Create an iterator from an endpoint, host name and service name. Create an iterator from a sequence of endpoints, host and service name. |
|
|
Dereference an iterator. |
|
|
Increment operator (prefix). Increment operator (postfix). |
|
|
Dereference an iterator. |
|
Name |
Description |
|---|---|
|
Test two iterators for inequality. |
|
|
Test two iterators for equality. |
The ip::basic_resolver_iterator class
template is used to define iterators over the results returned by a resolver.
The iterator's value_type, obtained when the iterator is dereferenced, is:
const basic_resolver_entry<InternetProtocol>
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
typedef InternetProtocol protocol_type;
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver_query< InternetProtocol > query;
|
Name |
Description |
|---|---|
|
A bitmask type (C++ Std [lib.bitmask.types]). |
|
|
The protocol type associated with the endpoint query. |
|
Name |
Description |
|---|---|
|
Construct with specified service name for any protocol. Construct with specified service name for a given protocol. Construct with specified host name and service name for any protocol. Construct with specified host name and service name for a given protocol. |
|
|
Get the hints associated with the query. |
|
|
Get the host name associated with the query. |
|
|
Get the service name associated with the query. |
|
Name |
Description |
|---|---|
|
Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. |
|
|
If used with v4_mapped, return all matching IPv6 and IPv4 addresses. |
|
|
Determine the canonical name of the host specified in the query. |
|
|
Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. |
|
|
Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. |
|
|
Indicate that returned endpoint is intended for use as a locally bound socket endpoint. |
|
|
If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. |
The ip::basic_resolver_query class template
describes a query that can be passed to a resolver.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
Perform forward resolution of a query to a list of entries.
iterator resolve( const query & q); » more... iterator resolve( const query & q, boost::system::error_code & ec); » more...
Perform reverse resolution of an endpoint to a list of entries.
iterator resolve( const endpoint_type & e); » more... iterator resolve( const endpoint_type & e, boost::system::error_code & ec); » more...
Perform forward resolution of a query to a list of entries.
iterator resolve( const query & q);
This function is used to resolve a query into a list of endpoint entries.
A query object that determines what endpoints will be returned.
A forward-only iterator that can be used to traverse the list of endpoint entries.
Thrown on failure.
A default constructed iterator represents the end of the list.
A successful call to this function is guaranteed to return at least one entry.
Perform forward resolution of a query to a list of entries.
iterator resolve( const query & q, boost::system::error_code & ec);
This function is used to resolve a query into a list of endpoint entries.
A query object that determines what endpoints will be returned.
Set to indicate what error occurred, if any.
A forward-only iterator that can be used to traverse the list of endpoint entries. Returns a default constructed iterator if an error occurs.
A default constructed iterator represents the end of the list.
A successful call to this function is guaranteed to return at least one entry.
Perform reverse resolution of an endpoint to a list of entries.
iterator resolve( const endpoint_type & e);
This function is used to resolve an endpoint into a list of endpoint entries.
An endpoint object that determines what endpoints will be returned.
A forward-only iterator that can be used to traverse the list of endpoint entries.
Thrown on failure.
A default constructed iterator represents the end of the list.
A successful call to this function is guaranteed to return at least one entry.
Perform reverse resolution of an endpoint to a list of entries.
iterator resolve( const endpoint_type & e, boost::system::error_code & ec);
This function is used to resolve an endpoint into a list of endpoint entries.
An endpoint object that determines what endpoints will be returned.
Set to indicate what error occurred, if any.
A forward-only iterator that can be used to traverse the list of endpoint entries. Returns a default constructed iterator if an error occurs.
A default constructed iterator represents the end of the list.
A successful call to this function is guaranteed to return at least one entry.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef ResolverService service_type;
Header: boost/asio/ip/basic_resolver.hpp
Convenience header: boost/asio.hpp
An entry produced by a resolver.
template< typename InternetProtocol> class basic_resolver_entry
|
Name |
Description |
|---|---|
|
The endpoint type associated with the endpoint entry. |
|
|
The protocol type associated with the endpoint entry. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct with specified endpoint, host name and service name. |
|
|
Get the endpoint associated with the entry. |
|
|
Get the host name associated with the entry. |
|
|
Convert to the endpoint associated with the entry. |
|
|
Get the service name associated with the entry. |
The ip::basic_resolver_entry
class template describes an entry as returned by a resolver.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver_entry.hpp
Convenience header: boost/asio.hpp
basic_resolver_entry(); » more...
Construct with specified endpoint, host name and service name.
basic_resolver_entry( const endpoint_type & ep, const std::string & host, const std::string & service); » more...
Default constructor.
basic_resolver_entry();
Construct with specified endpoint, host name and service name.
basic_resolver_entry( const endpoint_type & ep, const std::string & host, const std::string & service);
The endpoint type associated with the endpoint entry.
typedef InternetProtocol::endpoint endpoint_type;
Header: boost/asio/ip/basic_resolver_entry.hpp
Convenience header: boost/asio.hpp
The protocol type associated with the endpoint entry.
typedef InternetProtocol protocol_type;
Header: boost/asio/ip/basic_resolver_entry.hpp
Convenience header: boost/asio.hpp
An iterator over the entries produced by a resolver.
template< typename InternetProtocol> class basic_resolver_iterator
|
Name |
Description |
|---|---|
|
The type used for the distance between two iterators. |
|
|
The iterator category. |
|
|
The type of the result of applying operator->() to the iterator. |
|
|
The type of the result of applying operator*() to the iterator. |
|
|
The type of the value pointed to by the iterator. |
|
Name |
Description |
|---|---|
|
Default constructor creates an end iterator. |
|
|
Create an iterator from an addrinfo list returned by getaddrinfo. Create an iterator from an endpoint, host name and service name. Create an iterator from a sequence of endpoints, host and service name. |
|
|
Dereference an iterator. |
|
|
Increment operator (prefix). Increment operator (postfix). |
|
|
Dereference an iterator. |
|
Name |
Description |
|---|---|
|
Test two iterators for inequality. |
|
|
Test two iterators for equality. |
The ip::basic_resolver_iterator
class template is used to define iterators over the results returned by a
resolver.
The iterator's value_type, obtained when the iterator is dereferenced, is:
const basic_resolver_entry<InternetProtocol>
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
Create an iterator from an addrinfo list returned by getaddrinfo.
static basic_resolver_iterator create( boost::asio::detail::addrinfo_type * address_info, const std::string & host_name, const std::string & service_name); » more...
Create an iterator from an endpoint, host name and service name.
static basic_resolver_iterator create( const typename InternetProtocol::endpoint & endpoint, const std::string & host_name, const std::string & service_name); » more...
Create an iterator from a sequence of endpoints, host and service name.
template< typename EndpointIterator> static basic_resolver_iterator create( EndpointIterator begin, EndpointIterator end, const std::string & host_name, const std::string & service_name); » more...
Create an iterator from an addrinfo list returned by getaddrinfo.
static basic_resolver_iterator create( boost::asio::detail::addrinfo_type * address_info, const std::string & host_name, const std::string & service_name);
Create an iterator from an endpoint, host name and service name.
static basic_resolver_iterator create( const typename InternetProtocol::endpoint & endpoint, const std::string & host_name, const std::string & service_name);
Create an iterator from a sequence of endpoints, host and service name.
template< typename EndpointIterator> static basic_resolver_iterator create( EndpointIterator begin, EndpointIterator end, const std::string & host_name, const std::string & service_name);
The type used for the distance between two iterators.
typedef std::ptrdiff_t difference_type;
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
typedef std::forward_iterator_tag iterator_category;
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
const basic_resolver_entry< InternetProtocol > & operator *() const;
Test two iterators for inequality.
friend bool operator!=( const basic_resolver_iterator & a, const basic_resolver_iterator & b);
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
basic_resolver_iterator & operator++(); » more...
Increment operator (postfix).
basic_resolver_iterator operator++( int ); » more...
Increment operator (prefix).
basic_resolver_iterator & operator++();
Increment operator (postfix).
basic_resolver_iterator operator++( int );
const basic_resolver_entry< InternetProtocol > * operator->() const;
Test two iterators for equality.
friend bool operator==( const basic_resolver_iterator & a, const basic_resolver_iterator & b);
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
The type of the result of applying operator->()
to the iterator.
typedef const basic_resolver_entry< InternetProtocol > * pointer;
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
The type of the result of applying
operator*()
to the iterator.
typedef const basic_resolver_entry< InternetProtocol > & reference;
|
Name |
Description |
|---|---|
|
The endpoint type associated with the endpoint entry. |
|
|
The protocol type associated with the endpoint entry. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct with specified endpoint, host name and service name. |
|
|
Get the endpoint associated with the entry. |
|
|
Get the host name associated with the entry. |
|
|
Convert to the endpoint associated with the entry. |
|
|
Get the service name associated with the entry. |
The ip::basic_resolver_entry class template
describes an entry as returned by a resolver.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
The type of the value pointed to by the iterator.
typedef basic_resolver_entry< InternetProtocol > value_type;
|
Name |
Description |
|---|---|
|
The endpoint type associated with the endpoint entry. |
|
|
The protocol type associated with the endpoint entry. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct with specified endpoint, host name and service name. |
|
|
Get the endpoint associated with the entry. |
|
|
Get the host name associated with the entry. |
|
|
Convert to the endpoint associated with the entry. |
|
|
Get the service name associated with the entry. |
The ip::basic_resolver_entry class template
describes an entry as returned by a resolver.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver_iterator.hpp
Convenience header: boost/asio.hpp
An query to be passed to a resolver.
template< typename InternetProtocol> class basic_resolver_query : public ip::resolver_query_base
|
Name |
Description |
|---|---|
|
A bitmask type (C++ Std [lib.bitmask.types]). |
|
|
The protocol type associated with the endpoint query. |
|
Name |
Description |
|---|---|
|
Construct with specified service name for any protocol. Construct with specified service name for a given protocol. Construct with specified host name and service name for any protocol. Construct with specified host name and service name for a given protocol. |
|
|
Get the hints associated with the query. |
|
|
Get the host name associated with the query. |
|
|
Get the service name associated with the query. |
|
Name |
Description |
|---|---|
|
Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. |
|
|
If used with v4_mapped, return all matching IPv6 and IPv4 addresses. |
|
|
Determine the canonical name of the host specified in the query. |
|
|
Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. |
|
|
Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. |
|
|
Indicate that returned endpoint is intended for use as a locally bound socket endpoint. |
|
|
If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. |
The ip::basic_resolver_query
class template describes a query that can be passed to a resolver.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/basic_resolver_query.hpp
Convenience header: boost/asio.hpp
Inherited from ip::resolver_query_base.
Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system.
static const flags address_configured = implementation_defined;
Inherited from ip::resolver_query_base.
If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
static const flags all_matching = implementation_defined;
Construct with specified service name for any protocol.
basic_resolver_query( const std::string & service, resolver_query_base::flags resolve_flags = passive|address_configured); » more...
Construct with specified service name for a given protocol.
basic_resolver_query( const protocol_type & protocol, const std::string & service, resolver_query_base::flags resolve_flags = passive|address_configured); » more...
Construct with specified host name and service name for any protocol.
basic_resolver_query( const std::string & host, const std::string & service, resolver_query_base::flags resolve_flags = address_configured); » more...
Construct with specified host name and service name for a given protocol.
basic_resolver_query( const protocol_type & protocol, const std::string & host, const std::string & service, resolver_query_base::flags resolve_flags = address_configured); » more...
Construct with specified service name for any protocol.
basic_resolver_query( const std::string & service, resolver_query_base::flags resolve_flags = passive|address_configured);
This constructor is typically used to perform name resolution for local service binding.
A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number.
A set of flags that determine how name resolution should be performed. The default flags are suitable for local service binding.
On POSIX systems, service names are typically defined in the file /etc/services.
On Windows, service names may be found in the file c:\windows\system32\drivers\etc\services.
Operating systems may use additional locations when resolving service
names.
Construct with specified service name for a given protocol.
basic_resolver_query( const protocol_type & protocol, const std::string & service, resolver_query_base::flags resolve_flags = passive|address_configured);
This constructor is typically used to perform name resolution for local service binding with a specific protocol version.
A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.
A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number.
A set of flags that determine how name resolution should be performed. The default flags are suitable for local service binding.
On POSIX systems, service names are typically defined in the file /etc/services.
On Windows, service names may be found in the file c:\windows\system32\drivers\etc\services.
Operating systems may use additional locations when resolving service
names.
Construct with specified host name and service name for any protocol.
basic_resolver_query( const std::string & host, const std::string & service, resolver_query_base::flags resolve_flags = address_configured);
This constructor is typically used to perform name resolution for communication with remote hosts.
A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.
A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.
A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts.
On POSIX systems, host names may be locally defined in the file /etc/hosts.
On Windows, host names may be defined in the file c:\windows\system32\drivers\etc\hosts.
Remote host name resolution is performed using DNS. Operating systems
may use additional locations when resolving host names (such as NETBIOS
names on Windows).
On POSIX systems, service names are typically defined in the file /etc/services.
On Windows, service names may be found in the file c:\windows\system32\drivers\etc\services.
Operating systems may use additional locations when resolving service
names.
Construct with specified host name and service name for a given protocol.
basic_resolver_query( const protocol_type & protocol, const std::string & host, const std::string & service, resolver_query_base::flags resolve_flags = address_configured);
This constructor is typically used to perform name resolution for communication with remote hosts.
A protocol object, normally representing either the IPv4 or IPv6 version of an internet protocol.
A string identifying a location. May be a descriptive name or a numeric address string. If an empty string and the passive flag has been specified, the resolved endpoints are suitable for local service binding. If an empty string and passive is not specified, the resolved endpoints will use the loopback address.
A string identifying the requested service. This may be a descriptive name or a numeric string corresponding to a port number. May be an empty string, in which case all resolved endpoints will have a port number of 0.
A set of flags that determine how name resolution should be performed. The default flags are suitable for communication with remote hosts.
On POSIX systems, host names may be locally defined in the file /etc/hosts.
On Windows, host names may be defined in the file c:\windows\system32\drivers\etc\hosts.
Remote host name resolution is performed using DNS. Operating systems
may use additional locations when resolving host names (such as NETBIOS
names on Windows).
On POSIX systems, service names are typically defined in the file /etc/services.
On Windows, service names may be found in the file c:\windows\system32\drivers\etc\services.
Operating systems may use additional locations when resolving service
names.
Inherited from ip::resolver_query_base.
Determine the canonical name of the host specified in the query.
static const flags canonical_name = implementation_defined;
Inherited from ip::resolver_query_base.
A bitmask type (C++ Std [lib.bitmask.types]).
typedef unspecified flags;
Header: boost/asio/ip/basic_resolver_query.hpp
Convenience header: boost/asio.hpp
Inherited from ip::resolver_query_base.
Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted.
static const flags numeric_host = implementation_defined;
Inherited from ip::resolver_query_base.
Service name should be treated as a numeric string defining a port number and no name resolution should be attempted.
static const flags numeric_service = implementation_defined;
Inherited from ip::resolver_query_base.
Indicate that returned endpoint is intended for use as a locally bound socket endpoint.
static const flags passive = implementation_defined;
The protocol type associated with the endpoint query.
typedef InternetProtocol protocol_type;
Header: boost/asio/ip/basic_resolver_query.hpp
Convenience header: boost/asio.hpp
std::string host_name(); » more... std::string host_name( boost::system::error_code & ec); » more...
Header: boost/asio/ip/host_name.hpp
Convenience header: boost/asio.hpp
Get the current host name.
std::string host_name( boost::system::error_code & ec);
Encapsulates the flags needed for ICMP.
class icmp
|
Name |
Description |
|---|---|
|
The type of a ICMP endpoint. |
|
|
The ICMP resolver type. |
|
|
The ICMP socket type. |
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
|
Construct to represent the IPv4 ICMP protocol. |
|
|
Construct to represent the IPv6 ICMP protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The ip::icmp
class contains flags necessary for ICMP sockets.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/ip/icmp.hpp
Convenience header: boost/asio.hpp
typedef basic_endpoint< icmp > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Get the IP address associated with the endpoint. Set the IP address associated with the endpoint. |
|
|
Default constructor. Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the port associated with the endpoint. The port number is always in the host's byte order. Set the port associated with the endpoint. The port number is always in the host's byte order. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The ip::basic_endpoint class template
describes an endpoint that may be associated with a particular socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/icmp.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const icmp & p1, const icmp & p2);
Header: boost/asio/ip/icmp.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const icmp & p1, const icmp & p2);
Header: boost/asio/ip/icmp.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver< icmp > resolver;
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
The iterator type. |
|
|
The protocol type. |
|
|
The query type. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Asynchronously perform forward resolution of a query to a list of entries. Asynchronously perform reverse resolution of an endpoint to a list of entries. |
|
|
Constructor. |
|
|
Cancel any asynchronous operations that are waiting on the resolver. |
|
|
Get the io_service associated with the object. |
|
|
Perform forward resolution of a query to a list of entries. Perform reverse resolution of an endpoint to a list of entries. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The ip::basic_resolver class template
provides the ability to resolve a query to a list of endpoints.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/icmp.hpp
Convenience header: boost/asio.hpp
typedef basic_raw_socket< icmp > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_raw_socket without opening it. Construct and open a basic_raw_socket. Construct a basic_raw_socket, opening it and binding it to the given local endpoint. Construct a basic_raw_socket on an existing native socket. Move-construct a basic_raw_socket from another. Move-construct a basic_raw_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_raw_socket from another. Move-assign a basic_raw_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive raw data with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send raw data to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_raw_socket class template
provides asynchronous and blocking raw-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/icmp.hpp
Convenience header: boost/asio.hpp
Socket option determining whether outgoing multicast packets will be received on the same socket if it is a member of the multicast group.
typedef implementation_defined enable_loopback;
Implements the IPPROTO_IP/IP_MULTICAST_LOOP socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::multicast::enable_loopback option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::multicast::enable_loopback option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/ip/multicast.hpp
Convenience header: boost/asio.hpp
Socket option for time-to-live associated with outgoing multicast packets.
typedef implementation_defined hops;
Implements the IPPROTO_IP/IP_MULTICAST_TTL socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::multicast::hops option(4); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::multicast::hops option; socket.get_option(option); int ttl = option.value();
Header: boost/asio/ip/multicast.hpp
Convenience header: boost/asio.hpp
Socket option to join a multicast group on a specified interface.
typedef implementation_defined join_group;
Implements the IPPROTO_IP/IP_ADD_MEMBERSHIP socket option.
Setting the option to join a multicast group:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::address multicast_address = boost::asio::ip::address::from_string("225.0.0.1"); boost::asio::ip::multicast::join_group option(multicast_address); socket.set_option(option);
Header: boost/asio/ip/multicast.hpp
Convenience header: boost/asio.hpp
Socket option to leave a multicast group on a specified interface.
typedef implementation_defined leave_group;
Implements the IPPROTO_IP/IP_DROP_MEMBERSHIP socket option.
Setting the option to leave a multicast group:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::address multicast_address = boost::asio::ip::address::from_string("225.0.0.1"); boost::asio::ip::multicast::leave_group option(multicast_address); socket.set_option(option);
Header: boost/asio/ip/multicast.hpp
Convenience header: boost/asio.hpp
Socket option for local interface to use for outgoing multicast packets.
typedef implementation_defined outbound_interface;
Implements the IPPROTO_IP/IP_MULTICAST_IF socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::address_v4 local_interface = boost::asio::ip::address_v4::from_string("1.2.3.4"); boost::asio::ip::multicast::outbound_interface option(local_interface); socket.set_option(option);
Header: boost/asio/ip/multicast.hpp
Convenience header: boost/asio.hpp
The ip::resolver_query_base
class is used as a base for the ip::basic_resolver_query
class templates to provide a common place to define the flag constants.
class resolver_query_base
|
Name |
Description |
|---|---|
|
A bitmask type (C++ Std [lib.bitmask.types]). |
|
Name |
Description |
|---|---|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. |
|
|
If used with v4_mapped, return all matching IPv6 and IPv4 addresses. |
|
|
Determine the canonical name of the host specified in the query. |
|
|
Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. |
|
|
Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. |
|
|
Indicate that returned endpoint is intended for use as a locally bound socket endpoint. |
|
|
If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. |
Header: boost/asio/ip/resolver_query_base.hpp
Convenience header: boost/asio.hpp
Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system.
static const flags address_configured = implementation_defined;
If used with v4_mapped, return all matching IPv6 and IPv4 addresses.
static const flags all_matching = implementation_defined;
Determine the canonical name of the host specified in the query.
static const flags canonical_name = implementation_defined;
A bitmask type (C++ Std [lib.bitmask.types]).
typedef unspecified flags;
Header: boost/asio/ip/resolver_query_base.hpp
Convenience header: boost/asio.hpp
Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted.
static const flags numeric_host = implementation_defined;
Service name should be treated as a numeric string defining a port number and no name resolution should be attempted.
static const flags numeric_service = implementation_defined;
Indicate that returned endpoint is intended for use as a locally bound socket endpoint.
static const flags passive = implementation_defined;
If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses.
static const flags v4_mapped = implementation_defined;
Default service implementation for a resolver.
template< typename InternetProtocol> class resolver_service : public io_service::service
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The type of a resolver implementation. |
|
|
The iterator type. |
|
|
The protocol type. |
|
|
The query type. |
|
Name |
Description |
|---|---|
|
Asynchronously resolve a query to a list of entries. Asynchronously resolve an endpoint to a list of entries. |
|
|
Cancel pending asynchronous operations. |
|
|
Construct a new resolver implementation. |
|
|
Destroy a resolver implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Resolve a query to a list of entries. Resolve an endpoint to a list of entries. |
|
|
Construct a new resolver service for the specified io_service. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/ip/resolver_service.hpp
Convenience header: boost/asio.hpp
Asynchronously resolve a query to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( implementation_type & impl, const query_type & query, ResolveHandler handler); » more...
Asynchronously resolve an endpoint to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( implementation_type & impl, const endpoint_type & endpoint, ResolveHandler handler); » more...
Asynchronously resolve a query to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( implementation_type & impl, const query_type & query, ResolveHandler handler);
Asynchronously resolve an endpoint to a list of entries.
template< typename ResolveHandler> void-or-deduced async_resolve( implementation_type & impl, const endpoint_type & endpoint, ResolveHandler handler);
typedef InternetProtocol::endpoint endpoint_type;
Header: boost/asio/ip/resolver_service.hpp
Convenience header: boost/asio.hpp
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The type of a resolver implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/ip/resolver_service.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver_iterator< InternetProtocol > iterator_type;
|
Name |
Description |
|---|---|
|
The type used for the distance between two iterators. |
|
|
The iterator category. |
|
|
The type of the result of applying operator->() to the iterator. |
|
|
The type of the result of applying operator*() to the iterator. |
|
|
The type of the value pointed to by the iterator. |
|
Name |
Description |
|---|---|
|
Default constructor creates an end iterator. |
|
|
Create an iterator from an addrinfo list returned by getaddrinfo. Create an iterator from an endpoint, host name and service name. Create an iterator from a sequence of endpoints, host and service name. |
|
|
Dereference an iterator. |
|
|
Increment operator (prefix). Increment operator (postfix). |
|
|
Dereference an iterator. |
|
Name |
Description |
|---|---|
|
Test two iterators for inequality. |
|
|
Test two iterators for equality. |
The ip::basic_resolver_iterator class
template is used to define iterators over the results returned by a resolver.
The iterator's value_type, obtained when the iterator is dereferenced, is:
const basic_resolver_entry<InternetProtocol>
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/resolver_service.hpp
Convenience header: boost/asio.hpp
typedef InternetProtocol protocol_type;
Header: boost/asio/ip/resolver_service.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver_query< InternetProtocol > query_type;
|
Name |
Description |
|---|---|
|
A bitmask type (C++ Std [lib.bitmask.types]). |
|
|
The protocol type associated with the endpoint query. |
|
Name |
Description |
|---|---|
|
Construct with specified service name for any protocol. Construct with specified service name for a given protocol. Construct with specified host name and service name for any protocol. Construct with specified host name and service name for a given protocol. |
|
|
Get the hints associated with the query. |
|
|
Get the host name associated with the query. |
|
|
Get the service name associated with the query. |
|
Name |
Description |
|---|---|
|
Only return IPv4 addresses if a non-loopback IPv4 address is configured for the system. Only return IPv6 addresses if a non-loopback IPv6 address is configured for the system. |
|
|
If used with v4_mapped, return all matching IPv6 and IPv4 addresses. |
|
|
Determine the canonical name of the host specified in the query. |
|
|
Host name should be treated as a numeric string defining an IPv4 or IPv6 address and no name resolution should be attempted. |
|
|
Service name should be treated as a numeric string defining a port number and no name resolution should be attempted. |
|
|
Indicate that returned endpoint is intended for use as a locally bound socket endpoint. |
|
|
If the query protocol family is specified as IPv6, return IPv4-mapped IPv6 addresses on finding no IPv6 addresses. |
The ip::basic_resolver_query class template
describes a query that can be passed to a resolver.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/resolver_service.hpp
Convenience header: boost/asio.hpp
Resolve a query to a list of entries.
iterator_type resolve( implementation_type & impl, const query_type & query, boost::system::error_code & ec); » more...
Resolve an endpoint to a list of entries.
iterator_type resolve( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec); » more...
Resolve a query to a list of entries.
iterator_type resolve( implementation_type & impl, const query_type & query, boost::system::error_code & ec);
Resolve an endpoint to a list of entries.
iterator_type resolve( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec);
Construct a new resolver service for
the specified io_service.
resolver_service( boost::asio::io_service & io_service);
Encapsulates the flags needed for TCP.
class tcp
|
Name |
Description |
|---|---|
|
The TCP acceptor type. |
|
|
The type of a TCP endpoint. |
|
|
The TCP iostream type. |
|
|
Socket option for disabling the Nagle algorithm. |
|
|
The TCP resolver type. |
|
|
The TCP socket type. |
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
|
Construct to represent the IPv4 TCP protocol. |
|
|
Construct to represent the IPv6 TCP protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The ip::tcp
class contains flags necessary for TCP sockets.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
typedef basic_socket_acceptor< tcp > acceptor;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of an acceptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of an acceptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Accept a new connection. Accept a new connection and obtain the endpoint of the peer. |
|
|
Assigns an existing native acceptor to the acceptor. |
|
|
Start an asynchronous accept. |
|
|
Construct an acceptor without opening it. Construct an open acceptor. Construct an acceptor opened on the given endpoint. Construct a basic_socket_acceptor on an existing native acceptor. Move-construct a basic_socket_acceptor from another. Move-construct a basic_socket_acceptor from an acceptor of another protocol type. |
|
|
Bind the acceptor to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the acceptor. |
|
|
Close the acceptor. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the acceptor. |
|
|
Perform an IO control command on the acceptor. |
|
|
Determine whether the acceptor is open. |
|
|
Place the acceptor into the state where it will listen for new connections. |
|
|
Get the local endpoint of the acceptor. |
|
|
(Deprecated: Use native_handle().) Get the native acceptor representation. |
|
|
Get the native acceptor representation. |
|
|
Gets the non-blocking mode of the native acceptor implementation. Sets the non-blocking mode of the native acceptor implementation. |
|
|
Gets the non-blocking mode of the acceptor. Sets the non-blocking mode of the acceptor. |
|
|
Open the acceptor using the specified protocol. |
|
|
Move-assign a basic_socket_acceptor from another. Move-assign a basic_socket_acceptor from an acceptor of another protocol type. |
|
|
Set an option on the acceptor. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket_acceptor class template
is used for accepting new socket connections.
Distinct objects: Safe.
Shared objects: Unsafe.
Opening a socket acceptor with the SO_REUSEADDR option enabled:
boost::asio::ip::tcp::acceptor acceptor(io_service); boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port); acceptor.open(endpoint.protocol()); acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); acceptor.bind(endpoint); acceptor.listen();
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
typedef basic_endpoint< tcp > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Get the IP address associated with the endpoint. Set the IP address associated with the endpoint. |
|
|
Default constructor. Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the port associated with the endpoint. The port number is always in the host's byte order. Set the port associated with the endpoint. The port number is always in the host's byte order. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The ip::basic_endpoint class template
describes an endpoint that may be associated with a particular socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
typedef basic_socket_iostream< tcp > iostream;
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The endpoint type. |
|
|
The time type. |
|
Name |
Description |
|---|---|
|
Construct a basic_socket_iostream without establishing a connection. Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Close the connection. |
|
|
Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Get the last error associated with the stream. |
|
|
Get the stream's expiry time as an absolute time. Set the stream's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the stream's expiry time relative to now. |
|
|
Return a pointer to the underlying streambuf. |
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
Socket option for disabling the Nagle algorithm.
typedef implementation_defined no_delay;
Implements the IPPROTO_TCP/TCP_NODELAY socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::tcp::no_delay option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const tcp & p1, const tcp & p2);
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const tcp & p1, const tcp & p2);
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver< tcp > resolver;
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
The iterator type. |
|
|
The protocol type. |
|
|
The query type. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Asynchronously perform forward resolution of a query to a list of entries. Asynchronously perform reverse resolution of an endpoint to a list of entries. |
|
|
Constructor. |
|
|
Cancel any asynchronous operations that are waiting on the resolver. |
|
|
Get the io_service associated with the object. |
|
|
Perform forward resolution of a query to a list of entries. Perform reverse resolution of an endpoint to a list of entries. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The ip::basic_resolver class template
provides the ability to resolve a query to a list of endpoints.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
typedef basic_stream_socket< tcp > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Start an asynchronous write. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_stream_socket without opening it. Construct and open a basic_stream_socket. Construct a basic_stream_socket, opening it and binding it to the given local endpoint. Construct a basic_stream_socket on an existing native socket. Move-construct a basic_stream_socket from another. Move-construct a basic_stream_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_stream_socket from another. Move-assign a basic_stream_socket from a socket of another protocol type. |
|
|
Read some data from the socket. |
|
|
Receive some data on the socket. Receive some data on a connected socket. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
|
Write some data to the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_stream_socket class template
provides asynchronous and blocking stream-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/tcp.hpp
Convenience header: boost/asio.hpp
Encapsulates the flags needed for UDP.
class udp
|
Name |
Description |
|---|---|
|
The type of a UDP endpoint. |
|
|
The UDP resolver type. |
|
|
The UDP socket type. |
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Obtain an identifier for the type of the protocol. |
|
|
Construct to represent the IPv4 UDP protocol. |
|
|
Construct to represent the IPv6 UDP protocol. |
|
Name |
Description |
|---|---|
|
Compare two protocols for inequality. |
|
|
Compare two protocols for equality. |
The ip::udp
class contains flags necessary for UDP sockets.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/ip/udp.hpp
Convenience header: boost/asio.hpp
typedef basic_endpoint< udp > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Get the IP address associated with the endpoint. Set the IP address associated with the endpoint. |
|
|
Default constructor. Construct an endpoint using a port number, specified in the host's byte order. The IP address will be the any address (i.e. INADDR_ANY or in6addr_any). This constructor would typically be used for accepting new connections. Construct an endpoint using a port number and an IP address. This constructor may be used for accepting connections on a specific interface or for making a connection to a remote endpoint. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the port associated with the endpoint. The port number is always in the host's byte order. Set the port associated with the endpoint. The port number is always in the host's byte order. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The ip::basic_endpoint class template
describes an endpoint that may be associated with a particular socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/udp.hpp
Convenience header: boost/asio.hpp
Compare two protocols for inequality.
friend bool operator!=( const udp & p1, const udp & p2);
Header: boost/asio/ip/udp.hpp
Convenience header: boost/asio.hpp
Compare two protocols for equality.
friend bool operator==( const udp & p1, const udp & p2);
Header: boost/asio/ip/udp.hpp
Convenience header: boost/asio.hpp
typedef basic_resolver< udp > resolver;
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
The iterator type. |
|
|
The protocol type. |
|
|
The query type. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Asynchronously perform forward resolution of a query to a list of entries. Asynchronously perform reverse resolution of an endpoint to a list of entries. |
|
|
Constructor. |
|
|
Cancel any asynchronous operations that are waiting on the resolver. |
|
|
Get the io_service associated with the object. |
|
|
Perform forward resolution of a query to a list of entries. Perform reverse resolution of an endpoint to a list of entries. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The ip::basic_resolver class template
provides the ability to resolve a query to a list of endpoints.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/udp.hpp
Convenience header: boost/asio.hpp
typedef basic_datagram_socket< udp > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_datagram_socket without opening it. Construct and open a basic_datagram_socket. Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. Construct a basic_datagram_socket on an existing native socket. Move-construct a basic_datagram_socket from another. Move-construct a basic_datagram_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_datagram_socket from another. Move-assign a basic_datagram_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive a datagram with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send a datagram to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_datagram_socket class template
provides asynchronous and blocking datagram-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/ip/udp.hpp
Convenience header: boost/asio.hpp
Socket option for time-to-live associated with outgoing unicast packets.
typedef implementation_defined hops;
Implements the IPPROTO_IP/IP_UNICAST_TTL socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::unicast::hops option(4); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::ip::unicast::hops option; socket.get_option(option); int ttl = option.value();
Header: boost/asio/ip/unicast.hpp
Convenience header: boost/asio.hpp
Socket option for determining whether an IPv6 socket supports IPv6 communication only.
typedef implementation_defined v6_only;
Implements the IPPROTO_IPV6/IP_V6ONLY socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::v6_only option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::ip::v6_only option; socket.get_option(option); bool v6_only = option.value();
Header: boost/asio/ip/v6_only.hpp
Convenience header: boost/asio.hpp
Type trait used to determine whether a type can be used as a match condition function with read_until and async_read_until.
template< typename T> struct is_match_condition
|
Name |
Description |
|---|---|
|
The value member is true if the type may be used as a match condition. |
Header: boost/asio/read_until.hpp
Convenience header: boost/asio.hpp
The is_read_buffered
class is a traits class that may be used to determine whether a stream type
supports buffering of read data.
template< typename Stream> class is_read_buffered
|
Name |
Description |
|---|---|
|
The value member is true only if the Stream type supports buffering of read data. |
Header: boost/asio/is_read_buffered.hpp
Convenience header: boost/asio.hpp
The is_write_buffered class is a traits
class that may be used to determine whether a stream type supports buffering
of written data.
template< typename Stream> class is_write_buffered
|
Name |
Description |
|---|---|
|
The value member is true only if the Stream type supports buffering of written data. |
Header: boost/asio/is_write_buffered.hpp
Convenience header: boost/asio.hpp
Describes an endpoint for a UNIX socket.
template< typename Protocol> class basic_endpoint
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint using the specified path name. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the path associated with the endpoint. Set the path associated with the endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The local::basic_endpoint class template describes
an endpoint that may be associated with a particular UNIX socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
basic_endpoint(); » more...
Construct an endpoint using the specified path name.
basic_endpoint( const char * path_name); » more... basic_endpoint( const std::string & path_name); » more...
Copy constructor.
basic_endpoint( const basic_endpoint & other); » more...
Construct an endpoint using the specified path name.
basic_endpoint( const char * path_name);
Construct an endpoint using the specified path name.
basic_endpoint( const std::string & path_name);
Copy constructor.
basic_endpoint( const basic_endpoint & other);
Get the underlying endpoint in the native type.
data_type * data(); » more... const data_type * data() const; » more...
Get the underlying endpoint in the native type.
data_type * data();
Get the underlying endpoint in the native type.
const data_type * data() const;
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer.
typedef implementation_defined data_type;
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare two endpoints for inequality.
friend bool operator!=( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator<( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Output an endpoint as a string.
std::basic_ostream< Elem, Traits > & operator<<( std::basic_ostream< Elem, Traits > & os, const basic_endpoint< Protocol > & endpoint);
Used to output a human-readable string for a specified endpoint.
The output stream to which the string will be written.
The endpoint to be written.
The output stream.
Compare endpoints for ordering.
friend bool operator<=( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
basic_endpoint & operator=( const basic_endpoint & other);
Compare two endpoints for equality.
friend bool operator==( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator>( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Compare endpoints for ordering.
friend bool operator>=( const basic_endpoint< Protocol > & e1, const basic_endpoint< Protocol > & e2);
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Get the path associated with the endpoint.
std::string path() const; » more...
Set the path associated with the endpoint.
void path( const char * p); » more... void path( const std::string & p); » more...
Get the path associated with the endpoint.
std::string path() const;
Set the path associated with the endpoint.
void path( const char * p);
Set the path associated with the endpoint.
void path( const std::string & p);
The protocol type associated with the endpoint.
typedef Protocol protocol_type;
Header: boost/asio/local/basic_endpoint.hpp
Convenience header: boost/asio.hpp
Create a pair of connected sockets.
template< typename Protocol, typename SocketService1, typename SocketService2> void connect_pair( basic_socket< Protocol, SocketService1 > & socket1, basic_socket< Protocol, SocketService2 > & socket2); » more... template< typename Protocol, typename SocketService1, typename SocketService2> boost::system::error_code connect_pair( basic_socket< Protocol, SocketService1 > & socket1, basic_socket< Protocol, SocketService2 > & socket2, boost::system::error_code & ec); » more...
Header: boost/asio/local/connect_pair.hpp
Convenience header: boost/asio.hpp
Create a pair of connected sockets.
template< typename Protocol, typename SocketService1, typename SocketService2> void connect_pair( basic_socket< Protocol, SocketService1 > & socket1, basic_socket< Protocol, SocketService2 > & socket2);
Create a pair of connected sockets.
template< typename Protocol, typename SocketService1, typename SocketService2> boost::system::error_code connect_pair( basic_socket< Protocol, SocketService1 > & socket1, basic_socket< Protocol, SocketService2 > & socket2, boost::system::error_code & ec);
Encapsulates the flags needed for datagram-oriented UNIX sockets.
class datagram_protocol
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Obtain an identifier for the type of the protocol. |
The local::datagram_protocol class contains
flags necessary for datagram-oriented UNIX domain sockets.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/local/datagram_protocol.hpp
Convenience header: boost/asio.hpp
The type of a UNIX domain endpoint.
typedef basic_endpoint< datagram_protocol > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint using the specified path name. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the path associated with the endpoint. Set the path associated with the endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The local::basic_endpoint class template
describes an endpoint that may be associated with a particular UNIX socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/local/datagram_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_datagram_socket< datagram_protocol > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive on a connected socket. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send on a connected socket. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_datagram_socket without opening it. Construct and open a basic_datagram_socket. Construct a basic_datagram_socket, opening it and binding it to the given local endpoint. Construct a basic_datagram_socket on an existing native socket. Move-construct a basic_datagram_socket from another. Move-construct a basic_datagram_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_datagram_socket from another. Move-assign a basic_datagram_socket from a socket of another protocol type. |
|
|
Receive some data on a connected socket. |
|
|
Receive a datagram with the endpoint of the sender. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on a connected socket. |
|
|
Send a datagram to the specified endpoint. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_datagram_socket class template
provides asynchronous and blocking datagram-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/local/datagram_protocol.hpp
Convenience header: boost/asio.hpp
Encapsulates the flags needed for stream-oriented UNIX sockets.
class stream_protocol
|
Name |
Description |
|---|---|
|
The UNIX domain acceptor type. |
|
|
The type of a UNIX domain endpoint. |
|
|
The UNIX domain iostream type. |
|
|
The UNIX domain socket type. |
|
Name |
Description |
|---|---|
|
Obtain an identifier for the protocol family. |
|
|
Obtain an identifier for the protocol. |
|
|
Obtain an identifier for the type of the protocol. |
The local::stream_protocol class contains flags
necessary for stream-oriented UNIX domain sockets.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/local/stream_protocol.hpp
Convenience header: boost/asio.hpp
The UNIX domain acceptor type.
typedef basic_socket_acceptor< stream_protocol > acceptor;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of an acceptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of an acceptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Accept a new connection. Accept a new connection and obtain the endpoint of the peer. |
|
|
Assigns an existing native acceptor to the acceptor. |
|
|
Start an asynchronous accept. |
|
|
Construct an acceptor without opening it. Construct an open acceptor. Construct an acceptor opened on the given endpoint. Construct a basic_socket_acceptor on an existing native acceptor. Move-construct a basic_socket_acceptor from another. Move-construct a basic_socket_acceptor from an acceptor of another protocol type. |
|
|
Bind the acceptor to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the acceptor. |
|
|
Close the acceptor. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the acceptor. |
|
|
Perform an IO control command on the acceptor. |
|
|
Determine whether the acceptor is open. |
|
|
Place the acceptor into the state where it will listen for new connections. |
|
|
Get the local endpoint of the acceptor. |
|
|
(Deprecated: Use native_handle().) Get the native acceptor representation. |
|
|
Get the native acceptor representation. |
|
|
Gets the non-blocking mode of the native acceptor implementation. Sets the non-blocking mode of the native acceptor implementation. |
|
|
Gets the non-blocking mode of the acceptor. Sets the non-blocking mode of the acceptor. |
|
|
Open the acceptor using the specified protocol. |
|
|
Move-assign a basic_socket_acceptor from another. Move-assign a basic_socket_acceptor from an acceptor of another protocol type. |
|
|
Set an option on the acceptor. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_socket_acceptor class template
is used for accepting new socket connections.
Distinct objects: Safe.
Shared objects: Unsafe.
Opening a socket acceptor with the SO_REUSEADDR option enabled:
boost::asio::ip::tcp::acceptor acceptor(io_service); boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port); acceptor.open(endpoint.protocol()); acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); acceptor.bind(endpoint); acceptor.listen();
Header: boost/asio/local/stream_protocol.hpp
Convenience header: boost/asio.hpp
The type of a UNIX domain endpoint.
typedef basic_endpoint< stream_protocol > endpoint;
|
Name |
Description |
|---|---|
|
The type of the endpoint structure. This type is dependent on the underlying implementation of the socket layer. |
|
|
The protocol type associated with the endpoint. |
|
Name |
Description |
|---|---|
|
Default constructor. Construct an endpoint using the specified path name. Copy constructor. |
|
|
Get the capacity of the endpoint in the native type. |
|
|
Get the underlying endpoint in the native type. |
|
|
Assign from another endpoint. |
|
|
Get the path associated with the endpoint. Set the path associated with the endpoint. |
|
|
The protocol associated with the endpoint. |
|
|
Set the underlying size of the endpoint in the native type. |
|
|
Get the underlying size of the endpoint in the native type. |
|
Name |
Description |
|---|---|
|
Compare two endpoints for inequality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
|
Compare two endpoints for equality. |
|
|
Compare endpoints for ordering. |
|
|
Compare endpoints for ordering. |
|
Name |
Description |
|---|---|
|
Output an endpoint as a string. |
The local::basic_endpoint class template
describes an endpoint that may be associated with a particular UNIX socket.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/local/stream_protocol.hpp
Convenience header: boost/asio.hpp
The UNIX domain iostream type.
typedef basic_socket_iostream< stream_protocol > iostream;
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The endpoint type. |
|
|
The time type. |
|
Name |
Description |
|---|---|
|
Construct a basic_socket_iostream without establishing a connection. Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Close the connection. |
|
|
Establish a connection to an endpoint corresponding to a resolver query. |
|
|
Get the last error associated with the stream. |
|
|
Get the stream's expiry time as an absolute time. Set the stream's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the stream's expiry time relative to now. |
|
|
Return a pointer to the underlying streambuf. |
Header: boost/asio/local/stream_protocol.hpp
Convenience header: boost/asio.hpp
typedef basic_stream_socket< stream_protocol > socket;
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
The endpoint type. |
|
|
The underlying implementation type of I/O object. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
A basic_socket is always the lowest layer. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
The native representation of a socket. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a socket. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
The protocol type. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to the socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Start an asynchronous write. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Construct a basic_stream_socket without opening it. Construct and open a basic_stream_socket. Construct a basic_stream_socket, opening it and binding it to the given local endpoint. Construct a basic_stream_socket on an existing native socket. Move-construct a basic_stream_socket from another. Move-construct a basic_stream_socket from a socket of another protocol type. |
|
|
Bind the socket to the given local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close the socket. |
|
|
Connect the socket to the specified endpoint. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the socket. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint of the socket. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native socket representation. |
|
|
Get the native socket representation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open the socket using the specified protocol. |
|
|
Move-assign a basic_stream_socket from another. Move-assign a basic_stream_socket from a socket of another protocol type. |
|
|
Read some data from the socket. |
|
|
Receive some data on the socket. Receive some data on a connected socket. |
|
|
Get the remote endpoint of the socket. |
|
|
Send some data on the socket. |
|
|
Set an option on the socket. |
|
|
Disable sends or receives on the socket. |
|
|
Write some data to the socket. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_stream_socket class template
provides asynchronous and blocking stream-oriented socket functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/local/stream_protocol.hpp
Convenience header: boost/asio.hpp
Holds a buffer that can be modified.
class mutable_buffer
|
Name |
Description |
|---|---|
|
Construct an empty buffer. Construct a buffer to represent a given memory range. |
|
Name |
Description |
|---|---|
|
Create a new modifiable buffer that is offset from the start of another. |
The mutable_buffer
class provides a safe representation of a buffer that can be modified. It
does not own the underlying data, and so is cheap to copy or assign.
The contents of a buffer may be accessed using the buffer_size and buffer_cast functions:
boost::asio::mutable_buffer b1 = ...; std::size_t s1 = boost::asio::buffer_size(b1); unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
mutable_buffer(); » more...
Construct a buffer to represent a given memory range.
mutable_buffer( void * data, std::size_t size); » more...
Construct a buffer to represent a given memory range.
mutable_buffer( void * data, std::size_t size);
Create a new modifiable buffer that is offset from the start of another.
mutable_buffer operator+( const mutable_buffer & b, std::size_t start); » more... mutable_buffer operator+( std::size_t start, const mutable_buffer & b); » more...
Create a new modifiable buffer that is offset from the start of another.
mutable_buffer operator+( const mutable_buffer & b, std::size_t start);
Create a new modifiable buffer that is offset from the start of another.
mutable_buffer operator+( std::size_t start, const mutable_buffer & b);
Adapts a single modifiable buffer so that it meets the requirements of the MutableBufferSequence concept.
class mutable_buffers_1 : public mutable_buffer
|
Name |
Description |
|---|---|
|
A random-access iterator type that may be used to read elements. |
|
|
The type for each element in the list of buffers. |
|
Name |
Description |
|---|---|
|
Get a random-access iterator to the first element. |
|
|
Get a random-access iterator for one past the last element. |
|
|
Construct to represent a given memory range. Construct to represent a single modifiable buffer. |
|
Name |
Description |
|---|---|
|
Create a new modifiable buffer that is offset from the start of another. |
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
A random-access iterator type that may be used to read elements.
typedef const mutable_buffer * const_iterator;
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
Construct to represent a given memory range.
mutable_buffers_1( void * data, std::size_t size); » more...
Construct to represent a single modifiable buffer.
explicit mutable_buffers_1( const mutable_buffer & b); » more...
Construct to represent a given memory range.
mutable_buffers_1( void * data, std::size_t size);
Construct to represent a single modifiable buffer.
mutable_buffers_1( const mutable_buffer & b);
Create a new modifiable buffer that is offset from the start of another.
mutable_buffer operator+( const mutable_buffer & b, std::size_t start); » more... mutable_buffer operator+( std::size_t start, const mutable_buffer & b); » more...
Inherited from mutable_buffer.
Create a new modifiable buffer that is offset from the start of another.
mutable_buffer operator+( const mutable_buffer & b, std::size_t start);
Inherited from mutable_buffer.
Create a new modifiable buffer that is offset from the start of another.
mutable_buffer operator+( std::size_t start, const mutable_buffer & b);
The type for each element in the list of buffers.
typedef mutable_buffer value_type;
|
Name |
Description |
|---|---|
|
Construct an empty buffer. Construct a buffer to represent a given memory range. |
|
Name |
Description |
|---|---|
|
Create a new modifiable buffer that is offset from the start of another. |
The mutable_buffer
class provides a safe representation of a buffer that can be modified.
It does not own the underlying data, and so is cheap to copy or assign.
The contents of a buffer may be accessed using the buffer_size and buffer_cast functions:
boost::asio::mutable_buffer b1 = ...; std::size_t s1 = boost::asio::buffer_size(b1); unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
An implementation of both the ConstBufferSequence and MutableBufferSequence concepts to represent a null buffer sequence.
class null_buffers
|
Name |
Description |
|---|---|
|
A random-access iterator type that may be used to read elements. |
|
|
The type for each element in the list of buffers. |
|
Name |
Description |
|---|---|
|
Get a random-access iterator to the first element. |
|
|
Get a random-access iterator for one past the last element. |
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
A random-access iterator type that may be used to read elements.
typedef const mutable_buffer * const_iterator;
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
The type for each element in the list of buffers.
typedef mutable_buffer value_type;
|
Name |
Description |
|---|---|
|
Construct an empty buffer. Construct a buffer to represent a given memory range. |
|
Name |
Description |
|---|---|
|
Create a new modifiable buffer that is offset from the start of another. |
The mutable_buffer
class provides a safe representation of a buffer that can be modified.
It does not own the underlying data, and so is cheap to copy or assign.
The contents of a buffer may be accessed using the buffer_size and buffer_cast functions:
boost::asio::mutable_buffer b1 = ...; std::size_t s1 = boost::asio::buffer_size(b1); unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
The boost::asio::buffer_cast function permits violations
of type safety, so uses of it in application code should be carefully considered.
Header: boost/asio/buffer.hpp
Convenience header: boost/asio.hpp
An argument placeholder, for use with boost::bind(),
that corresponds to the bytes_transferred argument of a handler for asynchronous
functions such as boost::asio::basic_stream_socket::async_write_some or boost::asio::async_write.
unspecified bytes_transferred;
Header: boost/asio/placeholders.hpp
Convenience header: boost/asio.hpp
An argument placeholder, for use with boost::bind(), that corresponds to the error argument of a handler for any of the asynchronous functions.
unspecified error;
Header: boost/asio/placeholders.hpp
Convenience header: boost/asio.hpp
An argument placeholder, for use with boost::bind(), that corresponds to the iterator argument of a handler for asynchronous functions such as boost::asio::basic_resolver::async_resolve.
unspecified iterator;
Header: boost/asio/placeholders.hpp
Convenience header: boost/asio.hpp
An argument placeholder, for use with boost::bind(),
that corresponds to the signal_number argument of a handler for asynchronous
functions such as boost::asio::signal_set::async_wait.
unspecified signal_number;
Header: boost/asio/placeholders.hpp
Convenience header: boost/asio.hpp
Provides POSIX descriptor functionality.
template< typename DescriptorService> class basic_descriptor : public basic_io_object< DescriptorService >, public posix::descriptor_base
|
Name |
Description |
|---|---|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
The underlying implementation type of I/O object. |
|
|
A basic_descriptor is always the lowest layer. |
|
|
The native representation of a descriptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a descriptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native descriptor to the descriptor. |
|
|
Construct a basic_descriptor without opening it. Construct a basic_descriptor on an existing native descriptor. Move-construct a basic_descriptor from another. |
|
|
Cancel all asynchronous operations associated with the descriptor. |
|
|
Close the descriptor. |
|
|
Get the io_service associated with the object. |
|
|
Perform an IO control command on the descriptor. |
|
|
Determine whether the descriptor is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native descriptor representation. |
|
|
Get the native descriptor representation. |
|
|
Gets the non-blocking mode of the native descriptor implementation. Sets the non-blocking mode of the native descriptor implementation. |
|
|
Gets the non-blocking mode of the descriptor. Sets the non-blocking mode of the descriptor. |
|
|
Move-assign a basic_descriptor from another. |
|
|
Release ownership of the native descriptor implementation. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The posix::basic_descriptor class template
provides the ability to wrap a POSIX descriptor.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Assign an existing native descriptor to the descriptor.
void assign( const native_handle_type & native_descriptor); » more... boost::system::error_code assign( const native_handle_type & native_descriptor, boost::system::error_code & ec); » more...
Assign an existing native descriptor to the descriptor.
void assign( const native_handle_type & native_descriptor);
Assign an existing native descriptor to the descriptor.
boost::system::error_code assign( const native_handle_type & native_descriptor, boost::system::error_code & ec);
Construct a posix::basic_descriptor without opening
it.
explicit basic_descriptor( boost::asio::io_service & io_service); » more...
Construct a posix::basic_descriptor on an existing
native descriptor.
basic_descriptor( boost::asio::io_service & io_service, const native_handle_type & native_descriptor); » more...
Move-construct a posix::basic_descriptor from another.
basic_descriptor( basic_descriptor && other); » more...
Construct a posix::basic_descriptor without opening
it.
basic_descriptor( boost::asio::io_service & io_service);
This constructor creates a descriptor without opening it.
The io_service object that
the descriptor will use to dispatch handlers for any asynchronous
operations performed on the descriptor.
Construct a posix::basic_descriptor on an existing
native descriptor.
basic_descriptor( boost::asio::io_service & io_service, const native_handle_type & native_descriptor);
This constructor creates a descriptor object to hold an existing native descriptor.
The io_service object that
the descriptor will use to dispatch handlers for any asynchronous
operations performed on the descriptor.
A native descriptor.
Thrown on failure.
Move-construct a posix::basic_descriptor from another.
basic_descriptor( basic_descriptor && other);
This constructor moves a descriptor from one object to another.
The other posix::basic_descriptor object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_descriptor(io_service&) constructor.
Inherited from posix::descriptor_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::descriptor_base::bytes_readable command(true); descriptor.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the descriptor.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Cancel all asynchronous operations associated with the descriptor.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Cancel all asynchronous operations associated with the descriptor.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the descriptor.
void close();
This function is used to close the descriptor. Any asynchronous read
or write operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
Close the descriptor.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the descriptor. Any asynchronous read
or write operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the descriptor.
template< typename IoControlCommand> void io_control( IoControlCommand & command); » more... template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Perform an IO control command on the descriptor.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the descriptor.
The IO control command to be performed on the descriptor.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::posix::stream_descriptor::bytes_readable command; descriptor.io_control(command); std::size_t bytes_readable = command.get();
Perform an IO control command on the descriptor.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the descriptor.
The IO control command to be performed on the descriptor.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::posix::stream_descriptor::bytes_readable command; boost::system::error_code ec; descriptor.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a posix::basic_descriptor cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a posix::basic_descriptor cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
A posix::basic_descriptor is always the
lowest layer.
typedef basic_descriptor< DescriptorService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
The underlying implementation type of I/O object. |
|
|
A basic_descriptor is always the lowest layer. |
|
|
The native representation of a descriptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a descriptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native descriptor to the descriptor. |
|
|
Construct a basic_descriptor without opening it. Construct a basic_descriptor on an existing native descriptor. Move-construct a basic_descriptor from another. |
|
|
Cancel all asynchronous operations associated with the descriptor. |
|
|
Close the descriptor. |
|
|
Get the io_service associated with the object. |
|
|
Perform an IO control command on the descriptor. |
|
|
Determine whether the descriptor is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native descriptor representation. |
|
|
Get the native descriptor representation. |
|
|
Gets the non-blocking mode of the native descriptor implementation. Sets the non-blocking mode of the native descriptor implementation. |
|
|
Gets the non-blocking mode of the descriptor. Sets the non-blocking mode of the descriptor. |
|
|
Move-assign a basic_descriptor from another. |
|
|
Release ownership of the native descriptor implementation. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The posix::basic_descriptor class template
provides the ability to wrap a POSIX descriptor.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle().) Get the native descriptor representation.
native_type native();
This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided.
Get the native descriptor representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided.
The native representation of a descriptor.
typedef DescriptorService::native_handle_type native_handle_type;
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native descriptor implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native descriptor. This mode has no effect on the behaviour of the descriptor object's synchronous operations.
true if the underlying descriptor
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the descriptor object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native descriptor.
Sets the non-blocking mode of the native descriptor implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
If true, the underlying
descriptor is put into non-blocking mode and direct system calls
may fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
Sets the non-blocking mode of the native descriptor implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
If true, the underlying
descriptor is put into non-blocking mode and direct system calls
may fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
(Deprecated: Use native_handle_type.) The native representation of a descriptor.
typedef DescriptorService::native_handle_type native_type;
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the descriptor.
bool non_blocking() const; » more...
Sets the non-blocking mode of the descriptor.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the descriptor.
bool non_blocking() const;
true if the descriptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Sets the non-blocking mode of the descriptor.
void non_blocking( bool mode);
If true, the descriptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Sets the non-blocking mode of the descriptor.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the descriptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from posix::descriptor_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::descriptor_base::non_blocking_io command(true); descriptor.io_control(command);
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Move-assign a posix::basic_descriptor from another.
basic_descriptor & operator=( basic_descriptor && other);
This assignment operator moves a descriptor from one object to another.
The other posix::basic_descriptor object
from which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_descriptor(io_service&) constructor.
Release ownership of the native descriptor implementation.
native_handle_type release();
This function may be used to obtain the underlying representation of the
descriptor. After calling this function, is_open() returns false. The caller is responsible
for closing the descriptor.
All outstanding asynchronous read or write operations will finish immediately,
and the handlers for cancelled operations will be passed the boost::asio::error::operation_aborted error.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef DescriptorService service_type;
Header: boost/asio/posix/basic_descriptor.hpp
Convenience header: boost/asio.hpp
Provides stream-oriented descriptor functionality.
template< typename StreamDescriptorService = stream_descriptor_service> class basic_stream_descriptor : public posix::basic_descriptor< StreamDescriptorService >
|
Name |
Description |
|---|---|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
The underlying implementation type of I/O object. |
|
|
A basic_descriptor is always the lowest layer. |
|
|
The native representation of a descriptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a descriptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native descriptor to the descriptor. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_stream_descriptor without opening it. Construct a basic_stream_descriptor on an existing native descriptor. Move-construct a basic_stream_descriptor from another. |
|
|
Cancel all asynchronous operations associated with the descriptor. |
|
|
Close the descriptor. |
|
|
Get the io_service associated with the object. |
|
|
Perform an IO control command on the descriptor. |
|
|
Determine whether the descriptor is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native descriptor representation. |
|
|
Get the native descriptor representation. |
|
|
Gets the non-blocking mode of the native descriptor implementation. Sets the non-blocking mode of the native descriptor implementation. |
|
|
Gets the non-blocking mode of the descriptor. Sets the non-blocking mode of the descriptor. |
|
|
Move-assign a basic_stream_descriptor from another. |
|
|
Read some data from the descriptor. |
|
|
Release ownership of the native descriptor implementation. |
|
|
Write some data to the descriptor. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The posix::basic_stream_descriptor class template
provides asynchronous and blocking stream-oriented descriptor functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Assign an existing native descriptor to the descriptor.
void assign( const native_handle_type & native_descriptor); » more... boost::system::error_code assign( const native_handle_type & native_descriptor, boost::system::error_code & ec); » more...
Inherited from posix::basic_descriptor.
Assign an existing native descriptor to the descriptor.
void assign( const native_handle_type & native_descriptor);
Inherited from posix::basic_descriptor.
Assign an existing native descriptor to the descriptor.
boost::system::error_code assign( const native_handle_type & native_descriptor, boost::system::error_code & ec);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read data from the stream descriptor. The function call always returns immediately.
One or more buffers into which the data will be read. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. );
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().
The read operation may not read all of the requested number of bytes. Consider
using the async_read function if you need
to ensure that the requested amount of data is read before the asynchronous
operation completes.
To read into a single data buffer use the buffer function as follows:
descriptor.async_read_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write data to the stream descriptor. The function call always returns immediately.
One or more data buffers to be written to the descriptor. 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. );
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().
The write operation may not transmit all of the data to the peer. Consider
using the async_write function if you need
to ensure that all data is written before the asynchronous operation completes.
To write a single data buffer use the buffer function as follows:
descriptor.async_write_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Construct a posix::basic_stream_descriptor without
opening it.
explicit basic_stream_descriptor( boost::asio::io_service & io_service); » more...
Construct a posix::basic_stream_descriptor on an
existing native descriptor.
basic_stream_descriptor( boost::asio::io_service & io_service, const native_handle_type & native_descriptor); » more...
Move-construct a posix::basic_stream_descriptor from another.
basic_stream_descriptor( basic_stream_descriptor && other); » more...
Construct a posix::basic_stream_descriptor without
opening it.
basic_stream_descriptor( boost::asio::io_service & io_service);
This constructor creates a stream descriptor without opening it. The descriptor needs to be opened and then connected or accepted before data can be sent or received on it.
The io_service object that
the stream descriptor will use to dispatch handlers for any asynchronous
operations performed on the descriptor.
Construct a posix::basic_stream_descriptor on an
existing native descriptor.
basic_stream_descriptor( boost::asio::io_service & io_service, const native_handle_type & native_descriptor);
This constructor creates a stream descriptor object to hold an existing native descriptor.
The io_service object that
the stream descriptor will use to dispatch handlers for any asynchronous
operations performed on the descriptor.
The new underlying descriptor implementation.
Thrown on failure.
Move-construct a posix::basic_stream_descriptor from
another.
basic_stream_descriptor( basic_stream_descriptor && other);
This constructor moves a stream descriptor from one object to another.
The other posix::basic_stream_descriptor
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_stream_descriptor(io_service&) constructor.
Inherited from posix::descriptor_base.
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::descriptor_base::bytes_readable command(true); descriptor.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Cancel all asynchronous operations associated with the descriptor.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from posix::basic_descriptor.
Cancel all asynchronous operations associated with the descriptor.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from posix::basic_descriptor.
Cancel all asynchronous operations associated with the descriptor.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from posix::basic_descriptor.
Close the descriptor.
void close();
This function is used to close the descriptor. Any asynchronous read
or write operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Thrown on failure. Note that, even if the function indicates an error, the underlying descriptor is closed.
Inherited from posix::basic_descriptor.
Close the descriptor.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the descriptor. Any asynchronous read
or write operations will be cancelled immediately, and will complete
with the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any. Note that, even if the function indicates an error, the underlying descriptor is closed.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().)
The underlying implementation of the I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the descriptor.
void io_control( IoControlCommand & command); » more... boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec); » more...
Inherited from posix::basic_descriptor.
Perform an IO control command on the descriptor.
template< typename IoControlCommand> void io_control( IoControlCommand & command);
This function is used to execute an IO control command on the descriptor.
The IO control command to be performed on the descriptor.
Thrown on failure.
Getting the number of bytes ready to read:
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::posix::stream_descriptor::bytes_readable command; descriptor.io_control(command); std::size_t bytes_readable = command.get();
Inherited from posix::basic_descriptor.
Perform an IO control command on the descriptor.
template< typename IoControlCommand> boost::system::error_code io_control( IoControlCommand & command, boost::system::error_code & ec);
This function is used to execute an IO control command on the descriptor.
The IO control command to be performed on the descriptor.
Set to indicate what error occurred, if any.
Getting the number of bytes ready to read:
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::posix::stream_descriptor::bytes_readable command; boost::system::error_code ec; descriptor.io_control(command, ec); if (ec) { // An error occurred. } std::size_t bytes_readable = command.get();
Inherited from posix::basic_descriptor.
Determine whether the descriptor is open.
bool is_open() const;
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from posix::basic_descriptor.
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a posix::basic_descriptor cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from posix::basic_descriptor.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a posix::basic_descriptor cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from posix::basic_descriptor.
A posix::basic_descriptor is always the
lowest layer.
typedef basic_descriptor< StreamDescriptorService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
The underlying implementation type of I/O object. |
|
|
A basic_descriptor is always the lowest layer. |
|
|
The native representation of a descriptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a descriptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native descriptor to the descriptor. |
|
|
Construct a basic_descriptor without opening it. Construct a basic_descriptor on an existing native descriptor. Move-construct a basic_descriptor from another. |
|
|
Cancel all asynchronous operations associated with the descriptor. |
|
|
Close the descriptor. |
|
|
Get the io_service associated with the object. |
|
|
Perform an IO control command on the descriptor. |
|
|
Determine whether the descriptor is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native descriptor representation. |
|
|
Get the native descriptor representation. |
|
|
Gets the non-blocking mode of the native descriptor implementation. Sets the non-blocking mode of the native descriptor implementation. |
|
|
Gets the non-blocking mode of the descriptor. Sets the non-blocking mode of the descriptor. |
|
|
Move-assign a basic_descriptor from another. |
|
|
Release ownership of the native descriptor implementation. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The posix::basic_descriptor class template
provides the ability to wrap a POSIX descriptor.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Inherited from posix::basic_descriptor.
(Deprecated: Use native_handle().) Get the native descriptor representation.
native_type native();
This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided.
Inherited from posix::basic_descriptor.
Get the native descriptor representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the descriptor. This is intended to allow access to native descriptor functionality that is not otherwise provided.
The native representation of a descriptor.
typedef StreamDescriptorService::native_handle_type native_handle_type;
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking() const; » more...
Sets the non-blocking mode of the native descriptor implementation.
void native_non_blocking( bool mode); » more... boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from posix::basic_descriptor.
Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking() const;
This function is used to retrieve the non-blocking mode of the underlying native descriptor. This mode has no effect on the behaviour of the descriptor object's synchronous operations.
true if the underlying descriptor
is in non-blocking mode and direct system calls may fail with boost::asio::error::would_block (or the equivalent system
error).
The current non-blocking mode is cached by the descriptor object. Consequently, the return value may be incorrect if the non-blocking mode was set directly on the native descriptor.
Inherited from posix::basic_descriptor.
Sets the non-blocking mode of the native descriptor implementation.
void native_non_blocking( bool mode);
This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
If true, the underlying
descriptor is put into non-blocking mode and direct system calls
may fail with boost::asio::error::would_block
(or the equivalent system error).
Thrown on failure. If the mode
is false, but the
current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
Inherited from posix::basic_descriptor.
Sets the non-blocking mode of the native descriptor implementation.
boost::system::error_code native_non_blocking( bool mode, boost::system::error_code & ec);
This function is used to modify the non-blocking mode of the underlying native descriptor. It has no effect on the behaviour of the descriptor object's synchronous operations.
If true, the underlying
descriptor is put into non-blocking mode and direct system calls
may fail with boost::asio::error::would_block
(or the equivalent system error).
Set to indicate what error occurred, if any. If the mode is false,
but the current value of non_blocking() is true,
this function fails with boost::asio::error::invalid_argument,
as the combination does not make sense.
(Deprecated: Use native_handle_type.) The native representation of a descriptor.
typedef StreamDescriptorService::native_handle_type native_type;
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the descriptor.
bool non_blocking() const; » more...
Sets the non-blocking mode of the descriptor.
void non_blocking( bool mode); » more... boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec); » more...
Inherited from posix::basic_descriptor.
Gets the non-blocking mode of the descriptor.
bool non_blocking() const;
true if the descriptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately. If
false, synchronous operations
will block until complete.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from posix::basic_descriptor.
Sets the non-blocking mode of the descriptor.
void non_blocking( bool mode);
If true, the descriptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Thrown on failure.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from posix::basic_descriptor.
Sets the non-blocking mode of the descriptor.
boost::system::error_code non_blocking( bool mode, boost::system::error_code & ec);
If true, the descriptor's
synchronous operations will fail with boost::asio::error::would_block
if they are unable to perform the requested operation immediately.
If false, synchronous
operations will block until complete.
Set to indicate what error occurred, if any.
The non-blocking mode has no effect on the behaviour of asynchronous
operations. Asynchronous operations will never fail with the error boost::asio::error::would_block.
Inherited from posix::descriptor_base.
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::descriptor_base::non_blocking_io command(true); descriptor.io_control(command);
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Move-assign a posix::basic_stream_descriptor from another.
basic_stream_descriptor & operator=( basic_stream_descriptor && other);
This assignment operator moves a stream descriptor from one object to another.
The other posix::basic_stream_descriptor
object from which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_stream_descriptor(io_service&) constructor.
Read some data from the descriptor.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the descriptor.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
This function is used to read data from the stream descriptor. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
The number of bytes read.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To read into a single data buffer use the buffer function as follows:
descriptor.read_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Read some data from the descriptor.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read data from the stream descriptor. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes read. Returns 0 if an error occurred.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Inherited from posix::basic_descriptor.
Release ownership of the native descriptor implementation.
native_handle_type release();
This function may be used to obtain the underlying representation of the
descriptor. After calling this function, is_open() returns false. The caller is responsible
for closing the descriptor.
All outstanding asynchronous read or write operations will finish immediately,
and the handlers for cancelled operations will be passed the boost::asio::error::operation_aborted error.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef StreamDescriptorService service_type;
Header: boost/asio/posix/basic_stream_descriptor.hpp
Convenience header: boost/asio.hpp
Write some data to the descriptor.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write some data to the descriptor.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
This function is used to write data to the stream descriptor. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the descriptor.
The number of bytes written.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
To write a single data buffer use the buffer function as follows:
descriptor.write_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Write some data to the descriptor.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write data to the stream descriptor. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the descriptor.
Set to indicate what error occurred, if any.
The number of bytes written. Returns 0 if an error occurred.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
The posix::descriptor_base class is used as
a base for the posix::basic_stream_descriptor class template
so that we have a common place to define the associated IO control commands.
class descriptor_base
|
Name |
Description |
|---|---|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor. |
|
Name |
Description |
|---|---|
|
Protected destructor to prevent deletion through this type. |
Header: boost/asio/posix/descriptor_base.hpp
Convenience header: boost/asio.hpp
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::descriptor_base::bytes_readable command(true); descriptor.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/posix/descriptor_base.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::posix::stream_descriptor descriptor(io_service); ... boost::asio::descriptor_base::non_blocking_io command(true); descriptor.io_control(command);
Header: boost/asio/posix/descriptor_base.hpp
Convenience header: boost/asio.hpp
Typedef for the typical usage of a stream-oriented descriptor.
typedef basic_stream_descriptor stream_descriptor;
|
Name |
Description |
|---|---|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
The underlying implementation type of I/O object. |
|
|
A basic_descriptor is always the lowest layer. |
|
|
The native representation of a descriptor. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a descriptor. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the descriptor. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native descriptor to the descriptor. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_stream_descriptor without opening it. Construct a basic_stream_descriptor on an existing native descriptor. Move-construct a basic_stream_descriptor from another. |
|
|
Cancel all asynchronous operations associated with the descriptor. |
|
|
Close the descriptor. |
|
|
Get the io_service associated with the object. |
|
|
Perform an IO control command on the descriptor. |
|
|
Determine whether the descriptor is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native descriptor representation. |
|
|
Get the native descriptor representation. |
|
|
Gets the non-blocking mode of the native descriptor implementation. Sets the non-blocking mode of the native descriptor implementation. |
|
|
Gets the non-blocking mode of the descriptor. Sets the non-blocking mode of the descriptor. |
|
|
Move-assign a basic_stream_descriptor from another. |
|
|
Read some data from the descriptor. |
|
|
Release ownership of the native descriptor implementation. |
|
|
Write some data to the descriptor. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The posix::basic_stream_descriptor class template
provides asynchronous and blocking stream-oriented descriptor functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/posix/stream_descriptor.hpp
Convenience header: boost/asio.hpp
Default service implementation for a stream descriptor.
class stream_descriptor_service : public io_service::service
|
Name |
Description |
|---|---|
|
The type of a stream descriptor implementation. |
|
|
The native descriptor type. |
|
|
(Deprecated: Use native_handle_type.) The native descriptor type. |
|
Name |
Description |
|---|---|
|
Assign an existing native descriptor to a stream descriptor. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Cancel all asynchronous operations associated with the descriptor. |
|
|
Close a stream descriptor implementation. |
|
|
Construct a new stream descriptor implementation. |
|
|
Destroy a stream descriptor implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Perform an IO control command on the descriptor. |
|
|
Determine whether the descriptor is open. |
|
|
Move-assign from another stream descriptor implementation. |
|
|
Move-construct a new stream descriptor implementation. |
|
|
(Deprecated: Use native_handle().) Get the native descriptor implementation. |
|
|
Get the native descriptor implementation. |
|
|
Gets the non-blocking mode of the native descriptor implementation. Sets the non-blocking mode of the native descriptor implementation. |
|
|
Gets the non-blocking mode of the descriptor. Sets the non-blocking mode of the descriptor. |
|
|
Read some data from the stream. |
|
|
Release ownership of the native descriptor implementation. |
|
|
Construct a new stream descriptor service for the specified io_service. |
|
|
Write the given data to the stream. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/posix/stream_descriptor_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native descriptor to a stream descriptor.
boost::system::error_code assign( implementation_type & impl, const native_handle_type & native_descriptor, boost::system::error_code & ec);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( implementation_type & impl, const MutableBufferSequence & buffers, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( implementation_type & impl, const ConstBufferSequence & buffers, WriteHandler handler);
Cancel all asynchronous operations associated with the descriptor.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a stream descriptor implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The type of a stream descriptor implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/posix/stream_descriptor_service.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the descriptor.
template< typename IoControlCommand> boost::system::error_code io_control( implementation_type & impl, IoControlCommand & command, boost::system::error_code & ec);
Move-assign from another stream descriptor implementation.
void move_assign( implementation_type & impl, stream_descriptor_service & other_service, implementation_type & other_impl);
Move-construct a new stream descriptor implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native descriptor implementation.
native_type native( implementation_type & impl);
Get the native descriptor implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/posix/stream_descriptor_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the native descriptor implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native descriptor implementation.
bool native_non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the native descriptor implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
(Deprecated: Use native_handle_type.) The native descriptor type.
typedef implementation_defined native_type;
Header: boost/asio/posix/stream_descriptor_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the descriptor.
bool non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the descriptor.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the descriptor.
bool non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the descriptor.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
Read some data from the stream.
template< typename MutableBufferSequence> std::size_t read_some( implementation_type & impl, const MutableBufferSequence & buffers, boost::system::error_code & ec);
Release ownership of the native descriptor implementation.
native_handle_type release( implementation_type & impl);
Construct a new
stream descriptor service for the specified io_service.
stream_descriptor_service( boost::asio::io_service & io_service);
Write the given data to the stream.
template< typename ConstBufferSequence> std::size_t write_some( implementation_type & impl, const ConstBufferSequence & buffers, boost::system::error_code & ec);
Default service implementation for a raw socket.
template< typename Protocol> class raw_socket_service : public io_service::service
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The type of a raw socket. |
|
|
The native socket type. |
|
|
(Deprecated: Use native_handle_type.) The native socket type. |
|
|
The protocol type. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to a raw socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous receive that will get the endpoint of the sender. |
|
|
Start an asynchronous send. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close a raw socket implementation. |
|
|
Connect the raw socket to the specified endpoint. |
|
|
Construct a new raw socket implementation. |
|
|
Move-construct a new raw socket implementation from another protocol type. |
|
|
Destroy a raw socket implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Get a socket option. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint. |
|
|
Move-assign from another raw socket implementation. |
|
|
Move-construct a new raw socket implementation. |
|
|
(Deprecated: Use native_handle().) Get the native socket implementation. |
|
|
Get the native socket implementation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Construct a new raw socket service for the specified io_service. |
|
|
Receive some data from the peer. |
|
|
Receive raw data with the endpoint of the sender. |
|
|
Get the remote endpoint. |
|
|
Send the given data to the peer. |
|
|
Send raw data to the specified endpoint. |
|
|
Set a socket option. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/raw_socket_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to a raw socket.
boost::system::error_code assign( implementation_type & impl, const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, ConnectHandler handler);
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler);
Start an asynchronous receive that will get the endpoint of the sender.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive_from( implementation_type & impl, const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send_to( implementation_type & impl, const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, WriteHandler handler);
Determine whether the socket is at the out-of-band data mark.
bool at_mark( const implementation_type & impl, boost::system::error_code & ec) const;
Determine the number of bytes available for reading.
std::size_t available( const implementation_type & impl, boost::system::error_code & ec) const;
boost::system::error_code bind( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec);
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a raw socket implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Connect the raw socket to the specified endpoint.
boost::system::error_code connect( implementation_type & impl, const endpoint_type & peer_endpoint, boost::system::error_code & ec);
Move-construct a new raw socket implementation from another protocol type.
template< typename Protocol1> void converting_move_construct( implementation_type & impl, typename raw_socket_service< Protocol1 >::implementation_type & other_impl, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/raw_socket_service.hpp
Convenience header: boost/asio.hpp
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
template< typename GettableSocketOption> boost::system::error_code get_option( const implementation_type & impl, GettableSocketOption & option, boost::system::error_code & ec) const;
typedef implementation_defined implementation_type;
Header: boost/asio/raw_socket_service.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( implementation_type & impl, IoControlCommand & command, boost::system::error_code & ec);
endpoint_type local_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Move-assign from another raw socket implementation.
void move_assign( implementation_type & impl, raw_socket_service & other_service, implementation_type & other_impl);
Move-construct a new raw socket implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native socket implementation.
native_type native( implementation_type & impl);
Get the native socket implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/raw_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
(Deprecated: Use native_handle_type.) The native socket type.
typedef implementation_defined native_type;
Header: boost/asio/raw_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
boost::system::error_code open( implementation_type & impl, const protocol_type & protocol, boost::system::error_code & ec);
typedef Protocol protocol_type;
Header: boost/asio/raw_socket_service.hpp
Convenience header: boost/asio.hpp
Construct a new raw socket service
for the specified io_service.
raw_socket_service( boost::asio::io_service & io_service);
Receive some data from the peer.
template< typename MutableBufferSequence> std::size_t receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
Receive raw data with the endpoint of the sender.
template< typename MutableBufferSequence> std::size_t receive_from( implementation_type & impl, const MutableBufferSequence & buffers, endpoint_type & sender_endpoint, socket_base::message_flags flags, boost::system::error_code & ec);
endpoint_type remote_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Send the given data to the peer.
template< typename ConstBufferSequence> std::size_t send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
Send raw data to the specified endpoint.
template< typename ConstBufferSequence> std::size_t send_to( implementation_type & impl, const ConstBufferSequence & buffers, const endpoint_type & destination, socket_base::message_flags flags, boost::system::error_code & ec);
template< typename SettableSocketOption> boost::system::error_code set_option( implementation_type & impl, const SettableSocketOption & option, boost::system::error_code & ec);
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename MutableBufferSequence> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers); » more... template< typename SyncReadStream, typename MutableBufferSequence> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, boost::system::error_code & ec); » more... template< typename SyncReadStream, typename MutableBufferSequence, typename CompletionCondition> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition); » more... template< typename SyncReadStream, typename MutableBufferSequence, typename CompletionCondition> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec); » more... template< typename SyncReadStream, typename Allocator> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b); » more... template< typename SyncReadStream, typename Allocator> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b, boost::system::error_code & ec); » more... template< typename SyncReadStream, typename Allocator, typename CompletionCondition> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition); » more... template< typename SyncReadStream, typename Allocator, typename CompletionCondition> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec); » more...
Header: boost/asio/read.hpp
Convenience header: boost/asio.hpp
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename MutableBufferSequence> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.
The number of bytes transferred.
Thrown on failure.
To read into a single data buffer use the buffer function as follows:
boost::asio::read(s, boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::read( s, buffers, boost::asio::transfer_all());
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename MutableBufferSequence> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.
Set to indicate what error occurred, if any.
The number of bytes transferred.
To read into a single data buffer use the buffer function as follows:
boost::asio::read(s, boost::asio::buffer(data, size), ec);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::read( s, buffers, boost::asio::transfer_all(), ec);
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename MutableBufferSequence, typename CompletionCondition> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read_some function.
The number of bytes transferred.
Thrown on failure.
To read into a single data buffer use the buffer function as follows:
boost::asio::read(s, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32));
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename MutableBufferSequence, typename CompletionCondition> std::size_t read( SyncReadStream & s, const MutableBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the stream.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read_some function.
Set to indicate what error occurred, if any.
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename Allocator> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
The basic_streambuf object into
which the data will be read.
The number of bytes transferred.
Thrown on failure.
This overload is equivalent to calling:
boost::asio::read( s, b, boost::asio::transfer_all());
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename Allocator> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
The basic_streambuf object into
which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes transferred.
This overload is equivalent to calling:
boost::asio::read( s, b, boost::asio::transfer_all(), ec);
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename Allocator, typename CompletionCondition> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
The basic_streambuf object into
which the data will be read.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read_some function.
The number of bytes transferred.
Thrown on failure.
Attempt to read a certain amount of data from a stream before returning.
template< typename SyncReadStream, typename Allocator, typename CompletionCondition> std::size_t read( SyncReadStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
The basic_streambuf object into
which the data will be read.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's read_some function.
Set to indicate what error occurred, if any.
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers); » more... template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, boost::system::error_code & ec); » more... template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition); » more... template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec); » more... template< typename SyncRandomAccessReadDevice, typename Allocator> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b); » more... template< typename SyncRandomAccessReadDevice, typename Allocator> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, boost::system::error_code & ec); » more... template< typename SyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition); » more... template< typename SyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec); » more...
Header: boost/asio/read_at.hpp
Convenience header: boost/asio.hpp
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.
The number of bytes transferred.
Thrown on failure.
To read into a single data buffer use the buffer function as follows:
boost::asio::read_at(d, 42, boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::read_at( d, 42, buffers, boost::asio::transfer_all());
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.
Set to indicate what error occurred, if any.
The number of bytes transferred.
To read into a single data buffer use the buffer function as follows:
boost::asio::read_at(d, 42, boost::asio::buffer(data, size), ec);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::read_at( d, 42, buffers, boost::asio::transfer_all(), ec);
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read_some_at function.
The number of bytes transferred.
Thrown on failure.
To read into a single data buffer use the buffer function as follows:
boost::asio::read_at(d, 42, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32));
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename MutableBufferSequence, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, const MutableBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
One or more buffers into which the data will be read. The sum of the buffer sizes indicates the maximum number of bytes to read from the device.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read_some_at function.
Set to indicate what error occurred, if any.
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename Allocator> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
The basic_streambuf object into
which the data will be read.
The number of bytes transferred.
Thrown on failure.
This overload is equivalent to calling:
boost::asio::read_at( d, 42, b, boost::asio::transfer_all());
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename Allocator> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
The basic_streambuf object into
which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes transferred.
This overload is equivalent to calling:
boost::asio::read_at( d, 42, b, boost::asio::transfer_all(), ec);
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
The basic_streambuf object into
which the data will be read.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read_some_at function.
The number of bytes transferred.
Thrown on failure.
Attempt to read a certain amount of data at the specified offset before returning.
template< typename SyncRandomAccessReadDevice, typename Allocator, typename CompletionCondition> std::size_t read_at( SyncRandomAccessReadDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to read a certain number of bytes of data from a random access device at the specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's read_some_at function.
The device from which the data is to be read. The type must support the SyncRandomAccessReadDevice concept.
The offset at which the data will be read.
The basic_streambuf object into
which the data will be read.
The function object to be called to determine whether the read operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest read_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the read operation is complete. A non-zero return value indicates the maximum number of bytes to be read on the next call to the device's read_some_at function.
Set to indicate what error occurred, if any.
The number of bytes read. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Read data into a streambuf until it contains a delimiter, matches a regular expression, or a function object indicates a match.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, char delim); » more... template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, char delim, boost::system::error_code & ec); » more... template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const std::string & delim); » more... template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const std::string & delim, boost::system::error_code & ec); » more... template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const boost::regex & expr); » more... template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const boost::regex & expr, boost::system::error_code & ec); » more... template< typename SyncReadStream, typename Allocator, typename MatchCondition> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); » more... template< typename SyncReadStream, typename Allocator, typename MatchCondition> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, boost::system::error_code & ec, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0); » more...
Header: boost/asio/read_until.hpp
Convenience header: boost/asio.hpp
Read data into a streambuf until it contains a specified delimiter.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, char delim);
This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The delimiter character.
The number of bytes in the streambuf's get area up to and including the delimiter.
Thrown on failure.
After a successful read_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read_until operation to examine.
To read data into a streambuf until a newline is encountered:
boost::asio::streambuf b; boost::asio::read_until(s, b, '\n'); std::istream is(&b); std::string line; std::getline(is, line);
After the read_until operation
completes successfully, the buffer b
contains the delimiter:
{ 'a', 'b', ..., 'c', '\n', 'd', 'e', ... }
The call to std::getline then extracts the data up to
and including the delimiter, so that the string line
contains:
{ 'a', 'b', ..., 'c', '\n' }
The remaining data is left in the buffer b
as follows:
{ 'd', 'e', ... }
This data may be the start of a new line, to be extracted by a subsequent
read_until operation.
Read data into a streambuf until it contains a specified delimiter.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, char delim, boost::system::error_code & ec);
This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The delimiter character.
Set to indicate what error occurred, if any.
The number of bytes in the streambuf's get area up to and including the delimiter. Returns 0 if an error occurred.
After a successful read_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read_until operation to examine.
Read data into a streambuf until it contains a specified delimiter.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const std::string & delim);
This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The delimiter string.
The number of bytes in the streambuf's get area up to and including the delimiter.
Thrown on failure.
After a successful read_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read_until operation to examine.
To read data into a streambuf until a newline is encountered:
boost::asio::streambuf b; boost::asio::read_until(s, b, "\r\n"); std::istream is(&b); std::string line; std::getline(is, line);
After the read_until operation
completes successfully, the buffer b
contains the delimiter:
{ 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... }
The call to std::getline then extracts the data up to
and including the delimiter, so that the string line
contains:
{ 'a', 'b', ..., 'c', '\r', '\n' }
The remaining data is left in the buffer b
as follows:
{ 'd', 'e', ... }
This data may be the start of a new line, to be extracted by a subsequent
read_until operation.
Read data into a streambuf until it contains a specified delimiter.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const std::string & delim, boost::system::error_code & ec);
This function is used to read data into the specified streambuf until the streambuf's get area contains the specified delimiter. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the streambuf's get area already contains the delimiter, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The delimiter string.
Set to indicate what error occurred, if any.
The number of bytes in the streambuf's get area up to and including the delimiter. Returns 0 if an error occurred.
After a successful read_until operation, the streambuf may contain additional data beyond the delimiter. An application will typically leave that data in the streambuf for a subsequent read_until operation to examine.
Read data into a streambuf until some part of the data it contains matches a regular expression.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const boost::regex & expr);
This function is used to read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The regular expression.
The number of bytes in the streambuf's get area up to and including the substring that matches the regular expression.
Thrown on failure.
After a successful read_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent read_until operation to examine.
To read data into a streambuf until a CR-LF sequence is encountered:
boost::asio::streambuf b; boost::asio::read_until(s, b, boost::regex("\r\n")); std::istream is(&b); std::string line; std::getline(is, line);
After the read_until operation
completes successfully, the buffer b
contains the data which matched the regular expression:
{ 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... }
The call to std::getline then extracts the data up to
and including the match, so that the string line
contains:
{ 'a', 'b', ..., 'c', '\r', '\n' }
The remaining data is left in the buffer b
as follows:
{ 'd', 'e', ... }
This data may be the start of a new line, to be extracted by a subsequent
read_until operation.
Read data into a streambuf until some part of the data it contains matches a regular expression.
template< typename SyncReadStream, typename Allocator> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, const boost::regex & expr, boost::system::error_code & ec);
This function is used to read data into the specified streambuf until the streambuf's get area contains some data that matches a regular expression. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the streambuf's get area already contains data that matches the regular expression, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The regular expression.
Set to indicate what error occurred, if any.
The number of bytes in the streambuf's get area up to and including the substring that matches the regular expression. Returns 0 if an error occurred.
After a successful read_until operation, the streambuf may contain additional data beyond that which matched the regular expression. An application will typically leave that data in the streambuf for a subsequent read_until operation to examine.
Read data into a streambuf until a function object indicates a match.
template< typename SyncReadStream, typename Allocator, typename MatchCondition> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0);
This function is used to read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the match condition function object already indicates a match, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The function object to be called to determine whether a match exists. The signature of the function object must be:
pair<iterator, bool> match_condition(iterator begin, iterator end);
where iterator represents
the type:
buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
The iterator parameters begin
and end define the
range of bytes to be scanned to determine whether there is a match.
The first member
of the return value is an iterator marking one-past-the-end of the
bytes that have been consumed by the match function. This iterator
is used to calculate the begin
parameter for any subsequent invocation of the match condition. The
second member of
the return value is true if a match has been found, false otherwise.
The number of bytes in the streambuf's get area that have been fully consumed by the match function.
Thrown on failure.
After a successful read_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent
The default implementation of the is_match_condition
type trait evaluates to true for function pointers and function objects
with a result_type typedef.
It must be specialised for other user-defined function objects.
To read data into a streambuf until whitespace is encountered:
typedef boost::asio::buffers_iterator< boost::asio::streambuf::const_buffers_type> iterator; std::pair<iterator, bool> match_whitespace(iterator begin, iterator end) { iterator i = begin; while (i != end) if (std::isspace(*i++)) return std::make_pair(i, true); return std::make_pair(i, false); } ... boost::asio::streambuf b; boost::asio::read_until(s, b, match_whitespace);
To read data into a streambuf until a matching character is found:
class match_char { public: explicit match_char(char c) : c_(c) {} template <typename Iterator> std::pair<Iterator, bool> operator()( Iterator begin, Iterator end) const { Iterator i = begin; while (i != end) if (c_ == *i++) return std::make_pair(i, true); return std::make_pair(i, false); } private: char c_; }; namespace asio { template <> struct is_match_condition<match_char> : public boost::true_type {}; } // namespace asio ... boost::asio::streambuf b; boost::asio::read_until(s, b, match_char('a'));
Read data into a streambuf until a function object indicates a match.
template< typename SyncReadStream, typename Allocator, typename MatchCondition> std::size_t read_until( SyncReadStream & s, boost::asio::basic_streambuf< Allocator > & b, MatchCondition match_condition, boost::system::error_code & ec, typename enable_if< is_match_condition< MatchCondition >::value >::type * = 0);
This function is used to read data into the specified streambuf until a user-defined match condition function object, when applied to the data contained in the streambuf, indicates a successful match. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's read_some function. If the match condition function object already indicates a match, the function returns immediately.
The stream from which the data is to be read. The type must support the SyncReadStream concept.
A streambuf object into which the data will be read.
The function object to be called to determine whether a match exists. The signature of the function object must be:
pair<iterator, bool> match_condition(iterator begin, iterator end);
where iterator represents
the type:
buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
The iterator parameters begin
and end define the
range of bytes to be scanned to determine whether there is a match.
The first member
of the return value is an iterator marking one-past-the-end of the
bytes that have been consumed by the match function. This iterator
is used to calculate the begin
parameter for any subsequent invocation of the match condition. The
second member of
the return value is true if a match has been found, false otherwise.
Set to indicate what error occurred, if any.
The number of bytes in the streambuf's get area that have been fully consumed by the match function. Returns 0 if an error occurred.
After a successful read_until operation, the streambuf may contain additional data beyond that which matched the function object. An application will typically leave that data in the streambuf for a subsequent
The default implementation of the is_match_condition
type trait evaluates to true for function pointers and function objects
with a result_type typedef.
It must be specialised for other user-defined function objects.
Default service implementation for a sequenced packet socket.
template< typename Protocol> class seq_packet_socket_service : public io_service::service
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The type of a sequenced packet socket implementation. |
|
|
The native socket type. |
|
|
(Deprecated: Use native_handle_type.) The native socket type. |
|
|
The protocol type. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to a sequenced packet socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Bind the sequenced packet socket to the specified local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close a sequenced packet socket implementation. |
|
|
Connect the sequenced packet socket to the specified endpoint. |
|
|
Construct a new sequenced packet socket implementation. |
|
|
Move-construct a new sequenced packet socket implementation from another protocol type. |
|
|
Destroy a sequenced packet socket implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Get a socket option. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint. |
|
|
Move-assign from another sequenced packet socket implementation. |
|
|
Move-construct a new sequenced packet socket implementation. |
|
|
(Deprecated: Use native_handle().) Get the native socket implementation. |
|
|
Get the native socket implementation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open a sequenced packet socket. |
|
|
Receive some data from the peer. |
|
|
Get the remote endpoint. |
|
|
Send the given data to the peer. |
|
|
Construct a new sequenced packet socket service for the specified io_service. |
|
|
Set a socket option. |
|
|
Disable sends or receives on the socket. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/seq_packet_socket_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to a sequenced packet socket.
boost::system::error_code assign( implementation_type & impl, const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, ConnectHandler handler);
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
Determine whether the socket is at the out-of-band data mark.
bool at_mark( const implementation_type & impl, boost::system::error_code & ec) const;
Determine the number of bytes available for reading.
std::size_t available( const implementation_type & impl, boost::system::error_code & ec) const;
Bind the sequenced packet socket to the specified local endpoint.
boost::system::error_code bind( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec);
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a sequenced packet socket implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Connect the sequenced packet socket to the specified endpoint.
boost::system::error_code connect( implementation_type & impl, const endpoint_type & peer_endpoint, boost::system::error_code & ec);
Construct a new sequenced packet socket implementation.
void construct( implementation_type & impl);
Move-construct a new sequenced packet socket implementation from another protocol type.
template< typename Protocol1> void converting_move_construct( implementation_type & impl, typename seq_packet_socket_service< Protocol1 >::implementation_type & other_impl, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/seq_packet_socket_service.hpp
Convenience header: boost/asio.hpp
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
template< typename GettableSocketOption> boost::system::error_code get_option( const implementation_type & impl, GettableSocketOption & option, boost::system::error_code & ec) const;
The type of a sequenced packet socket implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/seq_packet_socket_service.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( implementation_type & impl, IoControlCommand & command, boost::system::error_code & ec);
endpoint_type local_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Move-assign from another sequenced packet socket implementation.
void move_assign( implementation_type & impl, seq_packet_socket_service & other_service, implementation_type & other_impl);
Move-construct a new sequenced packet socket implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native socket implementation.
native_type native( implementation_type & impl);
Get the native socket implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/seq_packet_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
(Deprecated: Use native_handle_type.) The native socket type.
typedef implementation_defined native_type;
Header: boost/asio/seq_packet_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
Open a sequenced packet socket.
boost::system::error_code open( implementation_type & impl, const protocol_type & protocol, boost::system::error_code & ec);
typedef Protocol protocol_type;
Header: boost/asio/seq_packet_socket_service.hpp
Convenience header: boost/asio.hpp
Receive some data from the peer.
template< typename MutableBufferSequence> std::size_t receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags in_flags, socket_base::message_flags & out_flags, boost::system::error_code & ec);
endpoint_type remote_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Send the given data to the peer.
template< typename ConstBufferSequence> std::size_t send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
Construct a new sequenced
packet socket service for the specified io_service.
seq_packet_socket_service( boost::asio::io_service & io_service);
template< typename SettableSocketOption> boost::system::error_code set_option( implementation_type & impl, const SettableSocketOption & option, boost::system::error_code & ec);
Typedef for the typical usage of a serial port.
typedef basic_serial_port serial_port;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_serial_port is always the lowest layer. |
|
|
The native representation of a serial port. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a serial port. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native serial port to the serial port. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_serial_port without opening it. Construct and open a basic_serial_port. Construct a basic_serial_port on an existing native serial port. Move-construct a basic_serial_port from another. |
|
|
Cancel all asynchronous operations associated with the serial port. |
|
|
Close the serial port. |
|
|
Get the io_service associated with the object. |
|
|
Get an option from the serial port. |
|
|
Determine whether the serial port is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native serial port representation. |
|
|
Get the native serial port representation. |
|
|
Open the serial port using the specified device name. |
|
|
Move-assign a basic_serial_port from another. |
|
|
Read some data from the serial port. |
|
|
Send a break sequence to the serial port. |
|
|
Set an option on the serial port. |
|
|
Write some data to the serial port. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_serial_port class template
provides functionality that is common to all serial ports.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/serial_port.hpp
Convenience header: boost/asio.hpp
The serial_port_base
class is used as a base for the basic_serial_port class template
so that we have a common place to define the serial port options.
class serial_port_base
|
Name |
Description |
|---|---|
|
Serial port option to permit changing the baud rate. |
|
|
Serial port option to permit changing the character size. |
|
|
Serial port option to permit changing the flow control. |
|
|
Serial port option to permit changing the parity. |
|
|
Serial port option to permit changing the number of stop bits. |
|
Name |
Description |
|---|---|
|
Protected destructor to prevent deletion through this type. |
Header: boost/asio/serial_port_base.hpp
Convenience header: boost/asio.hpp
Serial port option to permit changing the baud rate.
class baud_rate
Implements changing the baud rate for a given serial port.
Header: boost/asio/serial_port_base.hpp
Convenience header: boost/asio.hpp
boost::system::error_code load( const BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec);
boost::system::error_code store( BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec) const;
Serial port option to permit changing the character size.
class character_size
|
Name |
Description |
|---|---|
Implements changing the character size for a given serial port.
Header: boost/asio/serial_port_base.hpp
Convenience header: boost/asio.hpp
boost::system::error_code load( const BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec);
boost::system::error_code store( BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec) const;
Serial port option to permit changing the flow control.
class flow_control
|
Name |
Description |
|---|---|
|
Name |
Description |
|---|---|
Implements changing the flow control for a given serial port.
Header: boost/asio/serial_port_base.hpp
Convenience header: boost/asio.hpp
boost::system::error_code load( const BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec);
boost::system::error_code store( BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec) const;
Serial port option to permit changing the parity.
class parity
|
Name |
Description |
|---|---|
Implements changing the parity for a given serial port.
Header: boost/asio/serial_port_base.hpp
Convenience header: boost/asio.hpp
boost::system::error_code load( const BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec);
boost::system::error_code store( BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec) const;
Serial port option to permit changing the number of stop bits.
class stop_bits
|
Name |
Description |
|---|---|
Implements changing the number of stop bits for a given serial port.
Header: boost/asio/serial_port_base.hpp
Convenience header: boost/asio.hpp
boost::system::error_code load( const BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec);
boost::system::error_code store( BOOST_ASIO_OPTION_STORAGE & storage, boost::system::error_code & ec) const;
Default service implementation for a serial port.
class serial_port_service : public io_service::service
|
Name |
Description |
|---|---|
|
The type of a serial port implementation. |
|
|
The native handle type. |
|
|
(Deprecated: Use native_handle_type.) The native handle type. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to a serial port. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close a serial port implementation. |
|
|
Construct a new serial port implementation. |
|
|
Destroy a serial port implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Get a serial port option. |
|
|
Determine whether the handle is open. |
|
|
Move-assign from another serial port implementation. |
|
|
Move-construct a new serial port implementation. |
|
|
(Deprecated: Use native_handle().) Get the native handle implementation. |
|
|
Get the native handle implementation. |
|
|
Open a serial port. |
|
|
Read some data from the stream. |
|
|
Send a break sequence to the serial port. |
|
|
Construct a new serial port service for the specified io_service. |
|
|
Set a serial port option. |
|
|
Write the given data to the stream. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/serial_port_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to a serial port.
boost::system::error_code assign( implementation_type & impl, const native_handle_type & handle, boost::system::error_code & ec);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( implementation_type & impl, const MutableBufferSequence & buffers, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( implementation_type & impl, const ConstBufferSequence & buffers, WriteHandler handler);
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a serial port implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
template< typename GettableSerialPortOption> boost::system::error_code get_option( const implementation_type & impl, GettableSerialPortOption & option, boost::system::error_code & ec) const;
The type of a serial port implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/serial_port_service.hpp
Convenience header: boost/asio.hpp
Move-assign from another serial port implementation.
void move_assign( implementation_type & impl, serial_port_service & other_service, implementation_type & other_impl);
Move-construct a new serial port implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native handle implementation.
native_type native( implementation_type & impl);
Get the native handle implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/serial_port_service.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native handle type.
typedef implementation_defined native_type;
Header: boost/asio/serial_port_service.hpp
Convenience header: boost/asio.hpp
boost::system::error_code open( implementation_type & impl, const std::string & device, boost::system::error_code & ec);
Read some data from the stream.
template< typename MutableBufferSequence> std::size_t read_some( implementation_type & impl, const MutableBufferSequence & buffers, boost::system::error_code & ec);
Send a break sequence to the serial port.
boost::system::error_code send_break( implementation_type & impl, boost::system::error_code & ec);
Construct a new serial port service
for the specified io_service.
serial_port_service( boost::asio::io_service & io_service);
template< typename SettableSerialPortOption> boost::system::error_code set_option( implementation_type & impl, const SettableSerialPortOption & option, boost::system::error_code & ec);
Write the given data to the stream.
template< typename ConstBufferSequence> std::size_t write_some( implementation_type & impl, const ConstBufferSequence & buffers, boost::system::error_code & ec);
Exception thrown when trying to add a duplicate service to an io_service.
class service_already_exists
|
Name |
Description |
|---|---|
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Typedef for the typical usage of a signal set.
typedef basic_signal_set signal_set;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Add a signal to a signal_set. |
|
|
Start an asynchronous operation to wait for a signal to be delivered. |
|
|
Construct a signal set without adding any signals. Construct a signal set and add one signal. Construct a signal set and add two signals. Construct a signal set and add three signals. |
|
|
Cancel all operations associated with the signal set. |
|
|
Remove all signals from a signal_set. |
|
|
Get the io_service associated with the object. |
|
|
Remove a signal from a signal_set. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_signal_set
class template provides the ability to perform an asynchronous wait for one
or more signals to occur.
Most applications will use the signal_set typedef.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing an asynchronous wait:
void handler( const boost::system::error_code& error, int signal_number) { if (!error) { // A signal occurred. } } ... // Construct a signal set registered for process termination. boost::asio::signal_set signals(io_service, SIGINT, SIGTERM); // Start an asynchronous wait for one of the signals to occur. signals.async_wait(handler);
If a signal is registered with a signal_set, and the signal occurs when there are no waiting handlers, then the signal notification is queued. The next async_wait operation on that signal_set will dequeue the notification. If multiple notifications are queued, subsequent async_wait operations dequeue them one at a time. Signal notifications are dequeued in order of ascending signal number.
If a signal number is removed from a signal_set (using the remove or erase
member functions) then any queued notifications for that signal are discarded.
The same signal number may be registered with different signal_set objects. When the signal occurs, one handler is called for each signal_set object.
Note that multiple registration only works for signals that are registered
using Asio. The application must not also register a signal handler using
functions such as signal() or sigaction().
POSIX allows signals to be blocked using functions such as sigprocmask()
and pthread_sigmask().
For signals to be delivered, programs must ensure that any signals registered
using signal_set objects are unblocked in at least one thread.
Header: boost/asio/signal_set.hpp
Convenience header: boost/asio.hpp
Default service implementation for a signal set.
class signal_set_service : public io_service::service
|
Name |
Description |
|---|---|
|
The type of a signal set implementation. |
|
Name |
Description |
|---|---|
|
Add a signal to a signal_set. |
|
|
Cancel all operations associated with the signal set. |
|
|
Remove all signals from a signal_set. |
|
|
Construct a new signal set implementation. |
|
|
Destroy a signal set implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Remove a signal to a signal_set. |
|
|
Construct a new signal set service for the specified io_service. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/signal_set_service.hpp
Convenience header: boost/asio.hpp
boost::system::error_code add( implementation_type & impl, int signal_number, boost::system::error_code & ec);
template< typename SignalHandler> void-or-deduced async_wait( implementation_type & impl, SignalHandler handler);
Cancel all operations associated with the signal set.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Remove all signals from a signal_set.
boost::system::error_code clear( implementation_type & impl, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The type of a signal set implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/signal_set_service.hpp
Convenience header: boost/asio.hpp
Remove a signal to a signal_set.
boost::system::error_code remove( implementation_type & impl, int signal_number, boost::system::error_code & ec);
Construct a new signal set service
for the specified io_service.
signal_set_service( boost::asio::io_service & io_service);
Default service implementation for a socket acceptor.
template< typename Protocol> class socket_acceptor_service : public io_service::service
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The native type of the socket acceptor. |
|
|
The native acceptor type. |
|
|
(Deprecated: Use native_handle_type.) The native acceptor type. |
|
|
The protocol type. |
|
Name |
Description |
|---|---|
|
Accept a new connection. |
|
|
Assign an existing native acceptor to a socket acceptor. |
|
|
Start an asynchronous accept. |
|
|
Bind the socket acceptor to the specified local endpoint. |
|
|
Cancel all asynchronous operations associated with the acceptor. |
|
|
Close a socket acceptor implementation. |
|
|
Construct a new socket acceptor implementation. |
|
|
Move-construct a new socket acceptor implementation from another protocol type. |
|
|
Destroy a socket acceptor implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Get a socket option. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the acceptor is open. |
|
|
Place the socket acceptor into the state where it will listen for new connections. |
|
|
Get the local endpoint. |
|
|
Move-assign from another socket acceptor implementation. |
|
|
Move-construct a new socket acceptor implementation. |
|
|
(Deprecated: Use native_handle().) Get the native acceptor implementation. |
|
|
Get the native acceptor implementation. |
|
|
Gets the non-blocking mode of the native acceptor implementation. Sets the non-blocking mode of the native acceptor implementation. |
|
|
Gets the non-blocking mode of the acceptor. Sets the non-blocking mode of the acceptor. |
|
|
Open a new socket acceptor implementation. |
|
|
Set a socket option. |
|
|
Construct a new socket acceptor service for the specified io_service. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/socket_acceptor_service.hpp
Convenience header: boost/asio.hpp
template< typename Protocol1, typename SocketService> boost::system::error_code accept( implementation_type & impl, basic_socket< Protocol1, SocketService > & peer, endpoint_type * peer_endpoint, boost::system::error_code & ec, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0);
Assign an existing native acceptor to a socket acceptor.
boost::system::error_code assign( implementation_type & impl, const protocol_type & protocol, const native_handle_type & native_acceptor, boost::system::error_code & ec);
template< typename Protocol1, typename SocketService, typename AcceptHandler> void-or-deduced async_accept( implementation_type & impl, basic_socket< Protocol1, SocketService > & peer, endpoint_type * peer_endpoint, AcceptHandler handler, typename enable_if< is_convertible< Protocol, Protocol1 >::value >::type * = 0);
Bind the socket acceptor to the specified local endpoint.
boost::system::error_code bind( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec);
Cancel all asynchronous operations associated with the acceptor.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a socket acceptor implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Move-construct a new socket acceptor implementation from another protocol type.
template< typename Protocol1> void converting_move_construct( implementation_type & impl, typename socket_acceptor_service< Protocol1 >::implementation_type & other_impl, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
typedef protocol_type::endpoint endpoint_type;
Header: boost/asio/socket_acceptor_service.hpp
Convenience header: boost/asio.hpp
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
template< typename GettableSocketOption> boost::system::error_code get_option( const implementation_type & impl, GettableSocketOption & option, boost::system::error_code & ec) const;
The native type of the socket acceptor.
typedef implementation_defined implementation_type;
Header: boost/asio/socket_acceptor_service.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( implementation_type & impl, IoControlCommand & command, boost::system::error_code & ec);
Place the socket acceptor into the state where it will listen for new connections.
boost::system::error_code listen( implementation_type & impl, int backlog, boost::system::error_code & ec);
endpoint_type local_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Move-assign from another socket acceptor implementation.
void move_assign( implementation_type & impl, socket_acceptor_service & other_service, implementation_type & other_impl);
Move-construct a new socket acceptor implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native acceptor implementation.
native_type native( implementation_type & impl);
Get the native acceptor implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/socket_acceptor_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native acceptor implementation.
bool native_non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the native acceptor implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native acceptor implementation.
bool native_non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the native acceptor implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
(Deprecated: Use native_handle_type.) The native acceptor type.
typedef implementation_defined native_type;
Header: boost/asio/socket_acceptor_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the acceptor.
bool non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the acceptor.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the acceptor.
bool non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the acceptor.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
Open a new socket acceptor implementation.
boost::system::error_code open( implementation_type & impl, const protocol_type & protocol, boost::system::error_code & ec);
typedef Protocol protocol_type;
Header: boost/asio/socket_acceptor_service.hpp
Convenience header: boost/asio.hpp
template< typename SettableSocketOption> boost::system::error_code set_option( implementation_type & impl, const SettableSocketOption & option, boost::system::error_code & ec);
Construct a new socket acceptor
service for the specified io_service.
socket_acceptor_service( boost::asio::io_service & io_service);
The socket_base
class is used as a base for the basic_stream_socket and basic_datagram_socket class templates
so that we have a common place to define the shutdown_type and enum.
class socket_base
|
Name |
Description |
|---|---|
|
Socket option to permit sending of broadcast messages. |
|
|
IO control command to get the amount of data that can be read without blocking. |
|
|
Socket option to enable socket-level debugging. |
|
|
Socket option to prevent routing, use local interfaces only. |
|
|
Socket option to report aborted connections on accept. |
|
|
Socket option to send keep-alives. |
|
|
Socket option to specify whether the socket lingers on close if unsent data is present. |
|
|
Bitmask type for flags that can be passed to send and receive operations. |
|
|
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket. |
|
|
Socket option for the receive buffer size of a socket. |
|
|
Socket option for the receive low watermark. |
|
|
Socket option to allow the socket to be bound to an address that is already in use. |
|
|
Socket option for the send buffer size of a socket. |
|
|
Socket option for the send low watermark. |
|
|
Different ways a socket may be shutdown. |
|
Name |
Description |
|---|---|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
The maximum length of the queue of pending incoming connections. |
|
|
Specify that the data should not be subject to routing. |
|
|
Specifies that the data marks the end of a record. |
|
|
Process out-of-band data. |
|
|
Peek at incoming data without removing it from the input queue. |
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to permit sending of broadcast messages.
typedef implementation_defined broadcast;
Implements the SOL_SOCKET/SO_BROADCAST socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::broadcast option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
IO control command to get the amount of data that can be read without blocking.
typedef implementation_defined bytes_readable;
Implements the FIONREAD IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::bytes_readable command(true); socket.io_control(command); std::size_t bytes_readable = command.get();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to enable socket-level debugging.
typedef implementation_defined debug;
Implements the SOL_SOCKET/SO_DEBUG socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::debug option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to prevent routing, use local interfaces only.
typedef implementation_defined do_not_route;
Implements the SOL_SOCKET/SO_DONTROUTE socket option.
Setting the option:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::udp::socket socket(io_service); ... boost::asio::socket_base::do_not_route option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to report aborted connections on accept.
typedef implementation_defined enable_connection_aborted;
Implements a custom socket option that determines whether or not an accept
operation is permitted to fail with boost::asio::error::connection_aborted.
By default the option is false.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::enable_connection_aborted option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to send keep-alives.
typedef implementation_defined keep_alive;
Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option(true); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::keep_alive option; socket.get_option(option); bool is_set = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to specify whether the socket lingers on close if unsent data is present.
typedef implementation_defined linger;
Implements the SOL_SOCKET/SO_LINGER socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option(true, 30); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::linger option; socket.get_option(option); bool is_set = option.enabled(); unsigned short timeout = option.timeout();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
The maximum length of the queue of pending incoming connections.
static const int max_connections = implementation_defined;
Specify that the data should not be subject to routing.
static const int message_do_not_route = implementation_defined;
Specifies that the data marks the end of a record.
static const int message_end_of_record = implementation_defined;
Bitmask type for flags that can be passed to send and receive operations.
typedef int message_flags;
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
static const int message_out_of_band = implementation_defined;
Peek at incoming data without removing it from the input queue.
static const int message_peek = implementation_defined;
(Deprecated: Use non_blocking().) IO control command to set the blocking mode of the socket.
typedef implementation_defined non_blocking_io;
Implements the FIONBIO IO control command.
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::non_blocking_io command(true); socket.io_control(command);
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option for the receive buffer size of a socket.
typedef implementation_defined receive_buffer_size;
Implements the SOL_SOCKET/SO_RCVBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option for the receive low watermark.
typedef implementation_defined receive_low_watermark;
Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::receive_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option to allow the socket to be bound to an address that is already in use.
typedef implementation_defined reuse_address;
Implements the SOL_SOCKET/SO_REUSEADDR socket option.
Setting the option:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option(true); acceptor.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::acceptor acceptor(io_service); ... boost::asio::socket_base::reuse_address option; acceptor.get_option(option); bool is_set = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option for the send buffer size of a socket.
typedef implementation_defined send_buffer_size;
Implements the SOL_SOCKET/SO_SNDBUF socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option(8192); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_buffer_size option; socket.get_option(option); int size = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Socket option for the send low watermark.
typedef implementation_defined send_low_watermark;
Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
Setting the option:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option(1024); socket.set_option(option);
Getting the current option value:
boost::asio::ip::tcp::socket socket(io_service); ... boost::asio::socket_base::send_low_watermark option; socket.get_option(option); int size = option.value();
Header: boost/asio/socket_base.hpp
Convenience header: boost/asio.hpp
Different ways a socket may be shutdown.
enum shutdown_type
Shutdown the receive side of the socket.
Shutdown the send side of the socket.
Shutdown both send and receive on the socket.
Start a new stackful coroutine.
template< typename Handler, typename Function> void spawn( Handler handler, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); » more... template< typename Handler, typename Function> void spawn( basic_yield_context< Handler > ctx, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); » more... template< typename Function> void spawn( boost::asio::io_service::strand strand, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); » more... template< typename Function> void spawn( boost::asio::io_service & io_service, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes()); » more...
The spawn()
function is a high-level wrapper over the Boost.Coroutine library. This function
enables programs to implement asynchronous logic in a synchronous manner,
as illustrated by the following example:
boost::asio::spawn(my_strand, do_echo); // ... void do_echo(boost::asio::yield_context yield) { try { char data[128]; for (;;) { std::size_t length = my_socket.async_read_some( boost::asio::buffer(data), yield); boost::asio::async_write(my_socket, boost::asio::buffer(data, length), yield); } } catch (std::exception& e) { // ... } }
Header: boost/asio/spawn.hpp
Convenience header: None
Start a new stackful coroutine, calling the specified handler when it completes.
template< typename Handler, typename Function> void spawn( Handler handler, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
This function is used to launch a new coroutine.
A handler to be called when the coroutine exits. More importantly, the handler provides an execution context (via the the handler invocation hook) for the coroutine. The handler must have the signature:
void handler();
The coroutine function. The function must have the signature:
void function(basic_yield_context<Handler> yield);
Boost.Coroutine attributes used to customise the coroutine.
Start a new stackful coroutine, inheriting the execution context of another.
template< typename Handler, typename Function> void spawn( basic_yield_context< Handler > ctx, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
This function is used to launch a new coroutine.
Identifies the current coroutine as a parent of the new coroutine. This specifies that the new coroutine should inherit the execution context of the parent. For example, if the parent coroutine is executing in a particular strand, then the new coroutine will execute in the same strand.
The coroutine function. The function must have the signature:
void function(basic_yield_context<Handler> yield);
Boost.Coroutine attributes used to customise the coroutine.
Start a new stackful coroutine that executes in the context of a strand.
template< typename Function> void spawn( boost::asio::io_service::strand strand, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
This function is used to launch a new coroutine.
Identifies a strand. By starting multiple coroutines on the same strand, the implementation ensures that none of those coroutines can execute simultaneously.
The coroutine function. The function must have the signature:
void function(yield_context yield);
Boost.Coroutine attributes used to customise the coroutine.
Start a new stackful coroutine that executes on a given io_service.
template< typename Function> void spawn( boost::asio::io_service & io_service, Function function, const boost::coroutines::attributes & attributes = boost::coroutines::attributes());
This function is used to launch a new coroutine.
Identifies the io_service that will run
the coroutine. The new coroutine is implicitly given its own strand
within this io_service.
The coroutine function. The function must have the signature:
void function(yield_context yield);
Boost.Coroutine attributes used to customise the coroutine.
class context : public ssl::context_base, noncopyable
|
Name |
Description |
|---|---|
|
File format types. |
|
|
(Deprecated: Use native_handle_type.) The native type of the SSL context. |
|
|
Different methods supported by a context. |
|
|
The native handle type of the SSL context. |
|
|
Bitmask type for SSL options. |
|
|
Purpose of PEM password. |
|
Name |
Description |
|---|---|
|
Add certification authority for performing verification. |
|
|
Add a directory containing certificate authority files to be used for performing verification. |
|
|
Clear options on the context. |
|
|
Constructor. Deprecated constructor taking a reference to an io_service object. Move-construct a context from another. |
|
|
(Deprecated: Use native_handle().) Get the underlying implementation in the native type. |
|
|
Load a certification authority file for performing verification. |
|
|
Get the underlying implementation in the native type. |
|
|
Move-assign a context from another. |
|
|
Configures the context to use the default directories for finding certification authority certificates. |
|
|
Set options on the context. |
|
|
Set the password callback. |
|
|
Set the callback used to verify peer certificates. |
|
|
Set the peer verification depth. |
|
|
Set the peer verification mode. |
|
|
Use a certificate from a memory buffer. |
|
|
Use a certificate chain from a memory buffer. |
|
|
Use a certificate chain from a file. |
|
|
Use a certificate from a file. |
|
|
Use a private key from a memory buffer. |
|
|
Use a private key from a file. |
|
|
Use an RSA private key from a memory buffer. |
|
|
Use an RSA private key from a file. |
|
|
Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters. |
|
|
Use the specified file to obtain the temporary Diffie-Hellman parameters. |
|
|
Destructor. |
|
Name |
Description |
|---|---|
|
Implement various bug workarounds. |
|
|
Disable compression. Compression is disabled by default. |
|
|
Disable SSL v2. |
|
|
Disable SSL v3. |
|
|
Disable TLS v1. |
|
|
Disable TLS v1.1. |
|
|
Disable TLS v1.2. |
|
|
Always create a new key when using tmp_dh parameters. |
Header: boost/asio/ssl/context.hpp
Convenience header: boost/asio/ssl.hpp
Add certification authority for performing verification.
void add_certificate_authority( const const_buffer & ca); » more... boost::system::error_code add_certificate_authority( const const_buffer & ca, boost::system::error_code & ec); » more...
Add certification authority for performing verification.
void add_certificate_authority( const const_buffer & ca);
This function is used to add one trusted certification authority from a memory buffer.
The buffer containing the certification authority certificate. The certificate must use the PEM format.
Thrown on failure.
Calls SSL_CTX_get_cert_store
and X509_STORE_add_cert.
Add certification authority for performing verification.
boost::system::error_code add_certificate_authority( const const_buffer & ca, boost::system::error_code & ec);
This function is used to add one trusted certification authority from a memory buffer.
The buffer containing the certification authority certificate. The certificate must use the PEM format.
Set to indicate what error occurred, if any.
Calls SSL_CTX_get_cert_store
and X509_STORE_add_cert.
Add a directory containing certificate authority files to be used for performing verification.
void add_verify_path( const std::string & path); » more... boost::system::error_code add_verify_path( const std::string & path, boost::system::error_code & ec); » more...
Add a directory containing certificate authority files to be used for performing verification.
void add_verify_path( const std::string & path);
This function is used to specify the name of a directory containing certification authority certificates. Each file in the directory must contain a single certificate. The files must be named using the subject name's hash and an extension of ".0".
The name of a directory containing the certificates.
Thrown on failure.
Calls SSL_CTX_load_verify_locations.
Add a directory containing certificate authority files to be used for performing verification.
boost::system::error_code add_verify_path( const std::string & path, boost::system::error_code & ec);
This function is used to specify the name of a directory containing certification authority certificates. Each file in the directory must contain a single certificate. The files must be named using the subject name's hash and an extension of ".0".
The name of a directory containing the certificates.
Set to indicate what error occurred, if any.
Calls SSL_CTX_load_verify_locations.
void clear_options( options o); » more... boost::system::error_code clear_options( options o, boost::system::error_code & ec); » more...
Clear options on the context.
void clear_options( options o);
This function may be used to configure the SSL options used by the context.
A bitmask of options. The available option values are defined in
the ssl::context_base class. The
specified options, if currently enabled on the context, are cleared.
Thrown on failure.
Calls SSL_CTX_clear_options.
Clear options on the context.
boost::system::error_code clear_options( options o, boost::system::error_code & ec);
This function may be used to configure the SSL options used by the context.
A bitmask of options. The available option values are defined in
the ssl::context_base class. The
specified options, if currently enabled on the context, are cleared.
Set to indicate what error occurred, if any.
Calls SSL_CTX_clear_options.
explicit context( method m); » more...
Deprecated constructor taking a reference to an io_service object.
context( boost::asio::io_service & , method m); » more...
Move-construct a context from another.
context( context && other); » more...
Deprecated constructor taking a reference to an io_service object.
context( boost::asio::io_service & , method m);
Move-construct a context from another.
context( context && other);
This constructor moves an SSL context from one object to another.
The other context object from which the move will occur.
Following the move, the following operations only are valid for the moved-from object: * Destruction.
(Deprecated: Use native_handle().) Get the underlying implementation in
the native type.
impl_type impl();
This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided.
(Deprecated: Use native_handle_type.) The native type of the SSL context.
typedef SSL_CTX * impl_type;
Header: boost/asio/ssl/context.hpp
Convenience header: boost/asio/ssl.hpp
Load a certification authority file for performing verification.
void load_verify_file( const std::string & filename); » more... boost::system::error_code load_verify_file( const std::string & filename, boost::system::error_code & ec); » more...
Load a certification authority file for performing verification.
void load_verify_file( const std::string & filename);
This function is used to load one or more trusted certification authorities from a file.
The name of a file containing certification authority certificates in PEM format.
Thrown on failure.
Calls SSL_CTX_load_verify_locations.
Load a certification authority file for performing verification.
boost::system::error_code load_verify_file( const std::string & filename, boost::system::error_code & ec);
This function is used to load the certificates for one or more trusted certification authorities from a file.
The name of a file containing certification authority certificates in PEM format.
Set to indicate what error occurred, if any.
Calls SSL_CTX_load_verify_locations.
Different methods supported by a context.
enum method
Generic SSL version 2.
SSL version 2 client.
SSL version 2 server.
Generic SSL version 3.
SSL version 3 client.
SSL version 3 server.
Generic TLS version 1.
TLS version 1 client.
TLS version 1 server.
Generic SSL/TLS.
SSL/TLS client.
SSL/TLS server.
Generic TLS version 1.1.
TLS version 1.1 client.
TLS version 1.1 server.
Generic TLS version 1.2.
TLS version 1.2 client.
TLS version 1.2 server.
Get the underlying implementation in the native type.
native_handle_type native_handle();
This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided.
The native handle type of the SSL context.
typedef SSL_CTX * native_handle_type;
Header: boost/asio/ssl/context.hpp
Convenience header: boost/asio/ssl.hpp
Disable compression. Compression is disabled by default.
static const long no_compression = implementation_defined;
Move-assign a context from another.
context & operator=( context && other);
This assignment operator moves an SSL context from one object to another.
The other context object from which the move will occur.
Following the move, the following operations only are valid for the moved-from object: * Destruction.
typedef long options;
Header: boost/asio/ssl/context.hpp
Convenience header: boost/asio/ssl.hpp
enum password_purpose
The password is needed for reading/decryption.
The password is needed for writing/encryption.
Configures the context to use the default directories for finding certification authority certificates.
void set_default_verify_paths(); » more... boost::system::error_code set_default_verify_paths( boost::system::error_code & ec); » more...
Configures the context to use the default directories for finding certification authority certificates.
void set_default_verify_paths();
This function specifies that the context should use the default, system-dependent directories for locating certification authority certificates.
Thrown on failure.
Calls SSL_CTX_set_default_verify_paths.
Configures the context to use the default directories for finding certification authority certificates.
boost::system::error_code set_default_verify_paths( boost::system::error_code & ec);
This function specifies that the context should use the default, system-dependent directories for locating certification authority certificates.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_default_verify_paths.
void set_options( options o); » more... boost::system::error_code set_options( options o, boost::system::error_code & ec); » more...
Set options on the context.
void set_options( options o);
This function may be used to configure the SSL options used by the context.
A bitmask of options. The available option values are defined in
the ssl::context_base class. The
options are bitwise-ored with any existing value for the options.
Thrown on failure.
Calls SSL_CTX_set_options.
Set options on the context.
boost::system::error_code set_options( options o, boost::system::error_code & ec);
This function may be used to configure the SSL options used by the context.
A bitmask of options. The available option values are defined in
the ssl::context_base class. The
options are bitwise-ored with any existing value for the options.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_options.
template< typename PasswordCallback> void set_password_callback( PasswordCallback callback); » more... template< typename PasswordCallback> boost::system::error_code set_password_callback( PasswordCallback callback, boost::system::error_code & ec); » more...
Set the password callback.
template< typename PasswordCallback> void set_password_callback( PasswordCallback callback);
This function is used to specify a callback function to obtain password information about an encrypted key in PEM format.
The function object to be used for obtaining the password. The function signature of the handler must be:
std::string password_callback( std::size_t max_length, // The maximum size for a password. password_purpose purpose // Whether password is for reading or writing. );
The return value of the callback is a string containing the password.
Thrown on failure.
Calls SSL_CTX_set_default_passwd_cb.
Set the password callback.
template< typename PasswordCallback> boost::system::error_code set_password_callback( PasswordCallback callback, boost::system::error_code & ec);
This function is used to specify a callback function to obtain password information about an encrypted key in PEM format.
The function object to be used for obtaining the password. The function signature of the handler must be:
std::string password_callback( std::size_t max_length, // The maximum size for a password. password_purpose purpose // Whether password is for reading or writing. );
The return value of the callback is a string containing the password.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_default_passwd_cb.
Set the callback used to verify peer certificates.
template< typename VerifyCallback> void set_verify_callback( VerifyCallback callback); » more... template< typename VerifyCallback> boost::system::error_code set_verify_callback( VerifyCallback callback, boost::system::error_code & ec); » more...
Set the callback used to verify peer certificates.
template< typename VerifyCallback> void set_verify_callback( VerifyCallback callback);
This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
The function object to be used for verifying a certificate. The function signature of the handler must be:
bool verify_callback( bool preverified, // True if the certificate passed pre-verification. verify_context& ctx // The peer certificate and other context. );
The return value of the callback is true if the certificate has passed verification, false otherwise.
Thrown on failure.
Calls SSL_CTX_set_verify.
Set the callback used to verify peer certificates.
template< typename VerifyCallback> boost::system::error_code set_verify_callback( VerifyCallback callback, boost::system::error_code & ec);
This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
The function object to be used for verifying a certificate. The function signature of the handler must be:
bool verify_callback( bool preverified, // True if the certificate passed pre-verification. verify_context& ctx // The peer certificate and other context. );
The return value of the callback is true if the certificate has passed verification, false otherwise.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_verify.
Set the peer verification depth.
void set_verify_depth( int depth); » more... boost::system::error_code set_verify_depth( int depth, boost::system::error_code & ec); » more...
Set the peer verification depth.
void set_verify_depth( int depth);
This function may be used to configure the maximum verification depth allowed by the context.
Maximum depth for the certificate chain verification that shall be allowed.
Thrown on failure.
Calls SSL_CTX_set_verify_depth.
Set the peer verification depth.
boost::system::error_code set_verify_depth( int depth, boost::system::error_code & ec);
This function may be used to configure the maximum verification depth allowed by the context.
Maximum depth for the certificate chain verification that shall be allowed.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_verify_depth.
Set the peer verification mode.
void set_verify_mode( verify_mode v); » more... boost::system::error_code set_verify_mode( verify_mode v, boost::system::error_code & ec); » more...
Set the peer verification mode.
void set_verify_mode( verify_mode v);
This function may be used to configure the peer verification mode used by the context.
A bitmask of peer verification modes. See ssl::verify_mode for available
values.
Thrown on failure.
Calls SSL_CTX_set_verify.
Set the peer verification mode.
boost::system::error_code set_verify_mode( verify_mode v, boost::system::error_code & ec);
This function may be used to configure the peer verification mode used by the context.
A bitmask of peer verification modes. See ssl::verify_mode for available
values.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_verify.
Always create a new key when using tmp_dh parameters.
static const long single_dh_use = implementation_defined;
Use a certificate from a memory buffer.
void use_certificate( const const_buffer & certificate, file_format format); » more... boost::system::error_code use_certificate( const const_buffer & certificate, file_format format, boost::system::error_code & ec); » more...
Use a certificate from a memory buffer.
void use_certificate( const const_buffer & certificate, file_format format);
This function is used to load a certificate into the context from a buffer.
The buffer containing the certificate.
The certificate format (ASN.1 or PEM).
Thrown on failure.
Calls SSL_CTX_use_certificate
or SSL_CTX_use_certificate_ASN1.
Use a certificate from a memory buffer.
boost::system::error_code use_certificate( const const_buffer & certificate, file_format format, boost::system::error_code & ec);
This function is used to load a certificate into the context from a buffer.
The buffer containing the certificate.
The certificate format (ASN.1 or PEM).
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_certificate
or SSL_CTX_use_certificate_ASN1.
Use a certificate chain from a memory buffer.
void use_certificate_chain( const const_buffer & chain); » more... boost::system::error_code use_certificate_chain( const const_buffer & chain, boost::system::error_code & ec); » more...
Use a certificate chain from a memory buffer.
void use_certificate_chain( const const_buffer & chain);
This function is used to load a certificate chain into the context from a buffer.
The buffer containing the certificate chain. The certificate chain must use the PEM format.
Thrown on failure.
Calls SSL_CTX_use_certificate
and SSL_CTX_add_extra_chain_cert.
Use a certificate chain from a memory buffer.
boost::system::error_code use_certificate_chain( const const_buffer & chain, boost::system::error_code & ec);
This function is used to load a certificate chain into the context from a buffer.
The buffer containing the certificate chain. The certificate chain must use the PEM format.
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_certificate
and SSL_CTX_add_extra_chain_cert.
Use a certificate chain from a file.
void use_certificate_chain_file( const std::string & filename); » more... boost::system::error_code use_certificate_chain_file( const std::string & filename, boost::system::error_code & ec); » more...
Use a certificate chain from a file.
void use_certificate_chain_file( const std::string & filename);
This function is used to load a certificate chain into the context from a file.
The name of the file containing the certificate. The file must use the PEM format.
Thrown on failure.
Calls SSL_CTX_use_certificate_chain_file.
Use a certificate chain from a file.
boost::system::error_code use_certificate_chain_file( const std::string & filename, boost::system::error_code & ec);
This function is used to load a certificate chain into the context from a file.
The name of the file containing the certificate. The file must use the PEM format.
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_certificate_chain_file.
Use a certificate from a file.
void use_certificate_file( const std::string & filename, file_format format); » more... boost::system::error_code use_certificate_file( const std::string & filename, file_format format, boost::system::error_code & ec); » more...
Use a certificate from a file.
void use_certificate_file( const std::string & filename, file_format format);
This function is used to load a certificate into the context from a file.
The name of the file containing the certificate.
The file format (ASN.1 or PEM).
Thrown on failure.
Calls SSL_CTX_use_certificate_file.
Use a certificate from a file.
boost::system::error_code use_certificate_file( const std::string & filename, file_format format, boost::system::error_code & ec);
This function is used to load a certificate into the context from a file.
The name of the file containing the certificate.
The file format (ASN.1 or PEM).
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_certificate_file.
Use a private key from a memory buffer.
void use_private_key( const const_buffer & private_key, file_format format); » more... boost::system::error_code use_private_key( const const_buffer & private_key, file_format format, boost::system::error_code & ec); » more...
Use a private key from a memory buffer.
void use_private_key( const const_buffer & private_key, file_format format);
This function is used to load a private key into the context from a buffer.
The buffer containing the private key.
The private key format (ASN.1 or PEM).
Thrown on failure.
Calls SSL_CTX_use_PrivateKey
or SSL_CTX_use_PrivateKey_ASN1.
Use a private key from a memory buffer.
boost::system::error_code use_private_key( const const_buffer & private_key, file_format format, boost::system::error_code & ec);
This function is used to load a private key into the context from a buffer.
The buffer containing the private key.
The private key format (ASN.1 or PEM).
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_PrivateKey
or SSL_CTX_use_PrivateKey_ASN1.
Use a private key from a file.
void use_private_key_file( const std::string & filename, file_format format); » more... boost::system::error_code use_private_key_file( const std::string & filename, file_format format, boost::system::error_code & ec); » more...
Use a private key from a file.
void use_private_key_file( const std::string & filename, file_format format);
This function is used to load a private key into the context from a file.
The name of the file containing the private key.
The file format (ASN.1 or PEM).
Thrown on failure.
Calls SSL_CTX_use_PrivateKey_file.
Use a private key from a file.
boost::system::error_code use_private_key_file( const std::string & filename, file_format format, boost::system::error_code & ec);
This function is used to load a private key into the context from a file.
The name of the file containing the private key.
The file format (ASN.1 or PEM).
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_PrivateKey_file.
Use an RSA private key from a memory buffer.
void use_rsa_private_key( const const_buffer & private_key, file_format format); » more... boost::system::error_code use_rsa_private_key( const const_buffer & private_key, file_format format, boost::system::error_code & ec); » more...
Use an RSA private key from a memory buffer.
void use_rsa_private_key( const const_buffer & private_key, file_format format);
This function is used to load an RSA private key into the context from a buffer.
The buffer containing the RSA private key.
The private key format (ASN.1 or PEM).
Thrown on failure.
Calls SSL_CTX_use_RSAPrivateKey
or SSL_CTX_use_RSAPrivateKey_ASN1.
Use an RSA private key from a memory buffer.
boost::system::error_code use_rsa_private_key( const const_buffer & private_key, file_format format, boost::system::error_code & ec);
This function is used to load an RSA private key into the context from a buffer.
The buffer containing the RSA private key.
The private key format (ASN.1 or PEM).
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_RSAPrivateKey
or SSL_CTX_use_RSAPrivateKey_ASN1.
Use an RSA private key from a file.
void use_rsa_private_key_file( const std::string & filename, file_format format); » more... boost::system::error_code use_rsa_private_key_file( const std::string & filename, file_format format, boost::system::error_code & ec); » more...
Use an RSA private key from a file.
void use_rsa_private_key_file( const std::string & filename, file_format format);
This function is used to load an RSA private key into the context from a file.
The name of the file containing the RSA private key.
The file format (ASN.1 or PEM).
Thrown on failure.
Calls SSL_CTX_use_RSAPrivateKey_file.
Use an RSA private key from a file.
boost::system::error_code use_rsa_private_key_file( const std::string & filename, file_format format, boost::system::error_code & ec);
This function is used to load an RSA private key into the context from a file.
The name of the file containing the RSA private key.
The file format (ASN.1 or PEM).
Set to indicate what error occurred, if any.
Calls SSL_CTX_use_RSAPrivateKey_file.
Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters.
void use_tmp_dh( const const_buffer & dh); » more... boost::system::error_code use_tmp_dh( const const_buffer & dh, boost::system::error_code & ec); » more...
Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters.
void use_tmp_dh( const const_buffer & dh);
This function is used to load Diffie-Hellman parameters into the context from a buffer.
The memory buffer containing the Diffie-Hellman parameters. The buffer must use the PEM format.
Thrown on failure.
Calls SSL_CTX_set_tmp_dh.
Use the specified memory buffer to obtain the temporary Diffie-Hellman parameters.
boost::system::error_code use_tmp_dh( const const_buffer & dh, boost::system::error_code & ec);
This function is used to load Diffie-Hellman parameters into the context from a buffer.
The memory buffer containing the Diffie-Hellman parameters. The buffer must use the PEM format.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_tmp_dh.
Use the specified file to obtain the temporary Diffie-Hellman parameters.
void use_tmp_dh_file( const std::string & filename); » more... boost::system::error_code use_tmp_dh_file( const std::string & filename, boost::system::error_code & ec); » more...
Use the specified file to obtain the temporary Diffie-Hellman parameters.
void use_tmp_dh_file( const std::string & filename);
This function is used to load Diffie-Hellman parameters into the context from a file.
The name of the file containing the Diffie-Hellman parameters. The file must use the PEM format.
Thrown on failure.
Calls SSL_CTX_set_tmp_dh.
Use the specified file to obtain the temporary Diffie-Hellman parameters.
boost::system::error_code use_tmp_dh_file( const std::string & filename, boost::system::error_code & ec);
This function is used to load Diffie-Hellman parameters into the context from a file.
The name of the file containing the Diffie-Hellman parameters. The file must use the PEM format.
Set to indicate what error occurred, if any.
Calls SSL_CTX_set_tmp_dh.
The ssl::context_base
class is used as a base for the basic_context class template so that we have
a common place to define various enums.
class context_base
|
Name |
Description |
|---|---|
|
File format types. |
|
|
Different methods supported by a context. |
|
|
Bitmask type for SSL options. |
|
|
Purpose of PEM password. |
|
Name |
Description |
|---|---|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
Implement various bug workarounds. |
|
|
Disable compression. Compression is disabled by default. |
|
|
Disable SSL v2. |
|
|
Disable SSL v3. |
|
|
Disable TLS v1. |
|
|
Disable TLS v1.1. |
|
|
Disable TLS v1.2. |
|
|
Always create a new key when using tmp_dh parameters. |
Header: boost/asio/ssl/context_base.hpp
Convenience header: boost/asio/ssl.hpp
Different methods supported by a context.
enum method
Generic SSL version 2.
SSL version 2 client.
SSL version 2 server.
Generic SSL version 3.
SSL version 3 client.
SSL version 3 server.
Generic TLS version 1.
TLS version 1 client.
TLS version 1 server.
Generic SSL/TLS.
SSL/TLS client.
SSL/TLS server.
Generic TLS version 1.1.
TLS version 1.1 client.
TLS version 1.1 server.
Generic TLS version 1.2.
TLS version 1.2 client.
TLS version 1.2 server.
Disable compression. Compression is disabled by default.
static const long no_compression = implementation_defined;
static const long no_tlsv1_1 = implementation_defined;
static const long no_tlsv1_2 = implementation_defined;
typedef long options;
Header: boost/asio/ssl/context_base.hpp
Convenience header: boost/asio/ssl.hpp
enum password_purpose
The password is needed for reading/decryption.
The password is needed for writing/encryption.
Always create a new key when using tmp_dh parameters.
static const long single_dh_use = implementation_defined;
const boost::system::error_category & get_stream_category();
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
boost::system::error_code make_error_code( stream_errors e);
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
static const boost::system::error_category & stream_category = boost::asio::ssl::error::get_stream_category();
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
enum stream_errors
The underlying stream closed before the ssl stream gracefully shut down.
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
Verifies a certificate against a hostname according to the rules described in RFC 2818.
class rfc2818_verification
|
Name |
Description |
|---|---|
|
The type of the function object's result. |
|
Name |
Description |
|---|---|
|
Perform certificate verification. |
|
|
Constructor. |
The following example shows how to synchronously open a secure connection to a given host name:
using boost::asio::ip::tcp; namespace ssl = boost::asio::ssl; typedef ssl::stream<tcp::socket> ssl_socket; // Create a context that uses the default paths for finding CA certificates. ssl::context ctx(ssl::context::sslv23); ctx.set_default_verify_paths(); // Open a socket and connect it to the remote host. boost::asio::io_service io_service; ssl_socket sock(io_service, ctx); tcp::resolver resolver(io_service); tcp::resolver::query query("host.name", "https"); boost::asio::connect(sock.lowest_layer(), resolver.resolve(query)); sock.lowest_layer().set_option(tcp::no_delay(true)); // Perform SSL handshake and verify the remote host's certificate. sock.set_verify_mode(ssl::verify_peer); sock.set_verify_callback(ssl::rfc2818_verification("host.name")); sock.handshake(ssl_socket::client); // ... read and write as normal ...
Header: boost/asio/ssl/rfc2818_verification.hpp
Convenience header: boost/asio/ssl.hpp
The type of the function object's result.
typedef bool result_type;
Header: boost/asio/ssl/rfc2818_verification.hpp
Convenience header: boost/asio/ssl.hpp
rfc2818_verification( const std::string & host);
Provides stream-oriented functionality using SSL.
template< typename Stream> class stream : public ssl::stream_base, noncopyable
|
Name |
Description |
|---|---|
|
Structure for use with deprecated impl_type. |
|
|
Different handshake types. |
|
|
(Deprecated: Use native_handle_type.) The underlying implementation type. |
|
|
The type of the lowest layer. |
|
|
The native handle type of the SSL stream. |
|
|
The type of the next layer. |
|
Name |
Description |
|---|---|
|
Start an asynchronous SSL handshake. |
|
|
Start an asynchronous read. |
|
|
Asynchronously shut down SSL on the stream. |
|
|
Start an asynchronous write. |
|
|
Get the io_service associated with the object. |
|
|
Perform SSL handshaking. |
|
|
(Deprecated: Use native_handle().) Get the underlying implementation in the native type. |
|
|
Get a reference to the lowest layer. |
|
|
Get the underlying implementation in the native type. |
|
|
Get a reference to the next layer. |
|
|
Read some data from the stream. |
|
|
Set the callback used to verify peer certificates. |
|
|
Set the peer verification depth. |
|
|
Set the peer verification mode. |
|
|
Shut down SSL on the stream. |
|
|
Construct a stream. |
|
|
Write some data to the stream. |
|
|
Destructor. |
The stream class template provides asynchronous and blocking stream-oriented functionality using SSL.
Distinct objects: Safe.
Shared objects: Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand.
To use the SSL stream template with an ip::tcp::socket, you would write:
boost::asio::io_service io_service; boost::asio::ssl::context ctx(boost::asio::ssl::context::sslv23); boost::asio::ssl::stream<asio:ip::tcp::socket> sock(io_service, ctx);
Header: boost/asio/ssl/stream.hpp
Convenience header: boost/asio/ssl.hpp
Start an asynchronous SSL handshake.
template< typename HandshakeHandler> void-or-deduced async_handshake( handshake_type type, HandshakeHandler handler); » more... template< typename ConstBufferSequence, typename BufferedHandshakeHandler> void-or-deduced async_handshake( handshake_type type, const ConstBufferSequence & buffers, BufferedHandshakeHandler handler); » more...
Start an asynchronous SSL handshake.
template< typename HandshakeHandler> void-or-deduced async_handshake( handshake_type type, HandshakeHandler handler);
This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately.
The type of handshaking to be performed, i.e. as a client or as a server.
The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
Start an asynchronous SSL handshake.
template< typename ConstBufferSequence, typename BufferedHandshakeHandler> void-or-deduced async_handshake( handshake_type type, const ConstBufferSequence & buffers, BufferedHandshakeHandler handler);
This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately.
The type of handshaking to be performed, i.e. as a client or as a server.
The buffered data to be reused for the handshake. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called.
The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Amount of buffers used in handshake. );
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately.
The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. );
The async_read_some operation may not read all of the requested number
of bytes. Consider using the async_read function if you need
to ensure that the requested amount of data is read before the asynchronous
operation completes.
Asynchronously shut down SSL on the stream.
template< typename ShutdownHandler> void-or-deduced async_shutdown( ShutdownHandler handler);
This function is used to asynchronously shut down SSL on the stream. This function call always returns immediately.
The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately.
The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. );
The async_write_some operation may not transmit all of the data to the
peer. Consider using the async_write function if you need
to ensure that all data is written before the blocking operation completes.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the stream
uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that stream
will use to dispatch handlers. Ownership is not transferred to the caller.
void handshake( handshake_type type); » more... boost::system::error_code handshake( handshake_type type, boost::system::error_code & ec); » more... template< typename ConstBufferSequence> void handshake( handshake_type type, const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> boost::system::error_code handshake( handshake_type type, const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Perform SSL handshaking.
void handshake( handshake_type type);
This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
The type of handshaking to be performed, i.e. as a client or as a server.
Thrown on failure.
Perform SSL handshaking.
boost::system::error_code handshake( handshake_type type, boost::system::error_code & ec);
This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
The type of handshaking to be performed, i.e. as a client or as a server.
Set to indicate what error occurred, if any.
Perform SSL handshaking.
template< typename ConstBufferSequence> void handshake( handshake_type type, const ConstBufferSequence & buffers);
This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
The type of handshaking to be performed, i.e. as a client or as a server.
The buffered data to be reused for the handshake.
Thrown on failure.
Perform SSL handshaking.
template< typename ConstBufferSequence> boost::system::error_code handshake( handshake_type type, const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs.
The type of handshaking to be performed, i.e. as a client or as a server.
The buffered data to be reused for the handshake.
Set to indicate what error occurred, if any.
enum handshake_type
Perform handshaking as a client.
Perform handshaking as a server.
(Deprecated: Use native_handle().) Get the underlying implementation in
the native type.
impl_type impl();
This function may be used to obtain the underlying implementation of the context. This is intended to allow access to stream functionality that is not otherwise provided.
(Deprecated: Use native_handle_type.) The underlying implementation type.
typedef impl_struct * impl_type;
Header: boost/asio/ssl/stream.hpp
Convenience header: boost/asio/ssl.hpp
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more... const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of stream layers.
A reference to the lowest layer in the stack of stream layers. Ownership is not transferred to the caller.
Get a reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a reference to the lowest layer in a stack of stream layers.
A reference to the lowest layer in the stack of stream layers. Ownership is not transferred to the caller.
typedef next_layer_type::lowest_layer_type lowest_layer_type;
Header: boost/asio/ssl/stream.hpp
Convenience header: boost/asio/ssl.hpp
Get the underlying implementation in the native type.
native_handle_type native_handle();
This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided.
The native_handle()
function returns a pointer of type SSL* that is suitable for passing to functions
such as SSL_get_verify_result
and SSL_get_peer_certificate:
boost::asio::ssl::stream<asio:ip::tcp::socket> sock(io_service, ctx); // ... establish connection and perform handshake ... if (X509* cert = SSL_get_peer_certificate(sock.native_handle())) { if (SSL_get_verify_result(sock.native_handle()) == X509_V_OK) { // ... } }
The native handle type of the SSL stream.
typedef SSL * native_handle_type;
Header: boost/asio/ssl/stream.hpp
Convenience header: boost/asio/ssl.hpp
Get a reference to the next layer.
const next_layer_type & next_layer() const; » more... next_layer_type & next_layer(); » more...
Get a reference to the next layer.
const next_layer_type & next_layer() const;
This function returns a reference to the next layer in a stack of stream layers.
A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller.
Get a reference to the next layer.
next_layer_type & next_layer();
This function returns a reference to the next layer in a stack of stream layers.
A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller.
typedef remove_reference< Stream >::type next_layer_type;
Header: boost/asio/ssl/stream.hpp
Convenience header: boost/asio/ssl.hpp
Read some data from the stream.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the stream.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
The buffers into which the data will be read.
The number of bytes read.
Thrown on failure.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Read some data from the stream.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
The buffers into which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes read. Returns 0 if an error occurred.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Set the callback used to verify peer certificates.
template< typename VerifyCallback> void set_verify_callback( VerifyCallback callback); » more... template< typename VerifyCallback> boost::system::error_code set_verify_callback( VerifyCallback callback, boost::system::error_code & ec); » more...
Set the callback used to verify peer certificates.
template< typename VerifyCallback> void set_verify_callback( VerifyCallback callback);
This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
The function object to be used for verifying a certificate. The function signature of the handler must be:
bool verify_callback( bool preverified, // True if the certificate passed pre-verification. verify_context& ctx // The peer certificate and other context. );
The return value of the callback is true if the certificate has passed verification, false otherwise.
Thrown on failure.
Calls SSL_set_verify.
Set the callback used to verify peer certificates.
template< typename VerifyCallback> boost::system::error_code set_verify_callback( VerifyCallback callback, boost::system::error_code & ec);
This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate.
The function object to be used for verifying a certificate. The function signature of the handler must be:
bool verify_callback( bool preverified, // True if the certificate passed pre-verification. verify_context& ctx // The peer certificate and other context. );
The return value of the callback is true if the certificate has passed verification, false otherwise.
Set to indicate what error occurred, if any.
Calls SSL_set_verify.
Set the peer verification depth.
void set_verify_depth( int depth); » more... boost::system::error_code set_verify_depth( int depth, boost::system::error_code & ec); » more...
Set the peer verification depth.
void set_verify_depth( int depth);
This function may be used to configure the maximum verification depth allowed by the stream.
Maximum depth for the certificate chain verification that shall be allowed.
Thrown on failure.
Calls SSL_set_verify_depth.
Set the peer verification depth.
boost::system::error_code set_verify_depth( int depth, boost::system::error_code & ec);
This function may be used to configure the maximum verification depth allowed by the stream.
Maximum depth for the certificate chain verification that shall be allowed.
Set to indicate what error occurred, if any.
Calls SSL_set_verify_depth.
Set the peer verification mode.
void set_verify_mode( verify_mode v); » more... boost::system::error_code set_verify_mode( verify_mode v, boost::system::error_code & ec); » more...
Set the peer verification mode.
void set_verify_mode( verify_mode v);
This function may be used to configure the peer verification mode used by the stream. The new mode will override the mode inherited from the context.
A bitmask of peer verification modes. See ssl::verify_mode for available
values.
Thrown on failure.
Calls SSL_set_verify.
Set the peer verification mode.
boost::system::error_code set_verify_mode( verify_mode v, boost::system::error_code & ec);
This function may be used to configure the peer verification mode used by the stream. The new mode will override the mode inherited from the context.
A bitmask of peer verification modes. See ssl::verify_mode for available
values.
Set to indicate what error occurred, if any.
Calls SSL_set_verify.
void shutdown(); » more... boost::system::error_code shutdown( boost::system::error_code & ec); » more...
Shut down SSL on the stream.
void shutdown();
This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs.
Thrown on failure.
Shut down SSL on the stream.
boost::system::error_code shutdown( boost::system::error_code & ec);
This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs.
Set to indicate what error occurred, if any.
template< typename Arg> stream( Arg & arg, context & ctx);
This constructor creates a stream and initialises the underlying stream object.
The argument to be passed to initialise the underlying stream.
The SSL context to be used for the stream.
Write some data to the stream.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write some data to the stream.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs.
The data to be written.
The number of bytes written.
Thrown on failure.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
Write some data to the stream.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs.
The data to be written to the stream.
Set to indicate what error occurred, if any.
The number of bytes written. Returns 0 if an error occurred.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
Structure for use with deprecated impl_type.
struct impl_struct
|
Name |
Description |
|---|---|
Header: boost/asio/ssl/stream.hpp
Convenience header: boost/asio/ssl.hpp
The ssl::stream_base
class is used as a base for the ssl::stream
class template so that we have a common place to define various enums.
class stream_base
|
Name |
Description |
|---|---|
|
Different handshake types. |
|
Name |
Description |
|---|---|
|
Protected destructor to prevent deletion through this type. |
Header: boost/asio/ssl/stream_base.hpp
Convenience header: boost/asio/ssl.hpp
enum handshake_type
Perform handshaking as a client.
Perform handshaking as a server.
Do not request client certificate on renegotiation.
Ignored unless ssl::verify_peer
is set.
const int verify_client_once = implementation_defined;
Header: boost/asio/ssl/verify_mode.hpp
Convenience header: boost/asio/ssl.hpp
A simple wrapper around the X509_STORE_CTX type, used during verification of a peer certificate.
class verify_context : noncopyable
|
Name |
Description |
|---|---|
|
The native handle type of the verification context. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation in the native type. |
|
|
Constructor. |
The ssl::verify_context
does not own the underlying X509_STORE_CTX object.
Header: boost/asio/ssl/verify_context.hpp
Convenience header: boost/asio/ssl.hpp
Get the underlying implementation in the native type.
native_handle_type native_handle();
This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided.
The native handle type of the verification context.
typedef X509_STORE_CTX * native_handle_type;
Header: boost/asio/ssl/verify_context.hpp
Convenience header: boost/asio/ssl.hpp
Fail verification if the peer has no certificate.
Ignored unless ssl::verify_peer
is set.
const int verify_fail_if_no_peer_cert = implementation_defined;
Header: boost/asio/ssl/verify_mode.hpp
Convenience header: boost/asio/ssl.hpp
Bitmask type for peer verification.
typedef int verify_mode;
Possible values are:
Header: boost/asio/ssl/verify_mode.hpp
Convenience header: boost/asio/ssl.hpp
const int verify_none = implementation_defined;
Header: boost/asio/ssl/verify_mode.hpp
Convenience header: boost/asio/ssl.hpp
const int verify_peer = implementation_defined;
Header: boost/asio/ssl/verify_mode.hpp
Convenience header: boost/asio/ssl.hpp
Typedef for a timer based on the steady clock.
typedef basic_waitable_timer< chrono::steady_clock > steady_timer;
|
Name |
Description |
|---|---|
|
The clock type. |
|
|
The duration type of the clock. |
|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
The time point type of the clock. |
|
|
The wait traits type. |
|
Name |
Description |
|---|---|
|
Start an asynchronous wait on the timer. |
|
|
Constructor. Constructor to set a particular expiry time as an absolute time. Constructor to set a particular expiry time relative to now. |
|
|
Cancel any asynchronous operations that are waiting on the timer. |
|
|
Cancels one asynchronous operation that is waiting on the timer. |
|
|
Get the timer's expiry time as an absolute time. Set the timer's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the timer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Perform a blocking wait on the timer. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_waitable_timer class template
provides the ability to perform a blocking or asynchronous wait for a timer
to expire.
A waitable timer is always in one of two states: "expired" or "not
expired". If the wait() or async_wait() function is called on an expired timer,
the wait operation will complete immediately.
Most applications will use one of the steady_timer, system_timer or high_resolution_timer typedefs.
This waitable timer functionality is for use with the C++11 standard library's
<chrono> facility, or with the Boost.Chrono library.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing a blocking wait (C++11):
// Construct a timer without setting an expiry time. boost::asio::steady_timer timer(io_service); // Set an expiry time relative to now. timer.expires_from_now(std::chrono::seconds(5)); // Wait for the timer to expire. timer.wait();
Performing an asynchronous wait (C++11):
void handler(const boost::system::error_code& error) { if (!error) { // Timer expired. } } ... // Construct a timer with an absolute expiry time. boost::asio::steady_timer timer(io_service, std::chrono::steady_clock::now() + std::chrono::seconds(60)); // Start an asynchronous wait. timer.async_wait(handler);
Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
void on_some_event() { if (my_timer.expires_from_now(seconds(5)) > 0) { // We managed to cancel the timer. Start new asynchronous wait. my_timer.async_wait(on_timeout); } else { // Too late, timer has already expired! } } void on_timeout(const boost::system::error_code& e) { if (e != boost::asio::error::operation_aborted) { // Timer was not cancelled, take necessary action. } }
boost::asio::basic_waitable_timer::expires_from_now()
function cancels any pending asynchronous waits, and returns the number
of asynchronous waits that were cancelled. If it returns 0 then you were
too late and the wait handler has already been executed, or will soon
be executed. If it returns 1 then the wait handler was successfully cancelled.
boost::asio::error::operation_aborted.
This typedef uses the C++11 <chrono>
standard library facility, if available. Otherwise, it may use the Boost.Chrono
library. To explicitly utilise Boost.Chrono, use the basic_waitable_timer template directly:
typedef basic_waitable_timer<boost::chrono::steady_clock> timer;
Header: boost/asio/steady_timer.hpp
Convenience header: None
(Deprecated: Use io_service::strand.) Typedef for backwards compatibility.
typedef boost::asio::io_service::strand strand;
|
Name |
Description |
|---|---|
|
Request the strand to invoke the given handler. |
|
|
Get the io_service associated with the strand. |
|
|
Request the strand to invoke the given handler and return immediately. |
|
|
Determine whether the strand is running in the current thread. |
|
|
Constructor. |
|
|
Create a new handler that automatically dispatches the wrapped handler on the strand. |
|
|
Destructor. |
The io_service::strand class provides the ability
to post and dispatch handlers with the guarantee that none of those handlers
will execute concurrently.
Given:
s
a meeting completion
handler requirements
a1 which is
an arbitrary copy of a
made by the implementation
b meeting completion
handler requirements
b1 which is
an arbitrary copy of b
made by the implementation
if any of the following conditions are true:
s.post(a)
happens-before s.post(b)
s.post(a)
happens-before s.dispatch(b),
where the latter is performed outside the strand
s.dispatch(a)
happens-before s.post(b),
where the former is performed outside the strand
s.dispatch(a)
happens-before s.dispatch(b),
where both are performed outside the strand
then asio_handler_invoke(a1,
&a1) happens-before asio_handler_invoke(b1,
&b1).
Note that in the following case:
async_op_1(..., s.wrap(a)); async_op_2(..., s.wrap(b));
the completion of the first async operation will perform s.dispatch(a),
and the second will perform s.dispatch(b),
but the order in which those are performed is unspecified. That is, you cannot
state whether one happens-before the other. Therefore none of the above conditions
are met and no ordering guarantee is made.
The implementation makes no guarantee that handlers posted or dispatched
through different strand
objects will be invoked concurrently.
Distinct objects: Safe.
Shared objects: Safe.
Header: boost/asio/strand.hpp
Convenience header: boost/asio.hpp
Default service implementation for a stream socket.
template< typename Protocol> class stream_socket_service : public io_service::service
|
Name |
Description |
|---|---|
|
The endpoint type. |
|
|
The type of a stream socket implementation. |
|
|
The native socket type. |
|
|
(Deprecated: Use native_handle_type.) The native socket type. |
|
|
The protocol type. |
|
Name |
Description |
|---|---|
|
Assign an existing native socket to a stream socket. |
|
|
Start an asynchronous connect. |
|
|
Start an asynchronous receive. |
|
|
Start an asynchronous send. |
|
|
Determine whether the socket is at the out-of-band data mark. |
|
|
Determine the number of bytes available for reading. |
|
|
Bind the stream socket to the specified local endpoint. |
|
|
Cancel all asynchronous operations associated with the socket. |
|
|
Close a stream socket implementation. |
|
|
Connect the stream socket to the specified endpoint. |
|
|
Construct a new stream socket implementation. |
|
|
Move-construct a new stream socket implementation from another protocol type. |
|
|
Destroy a stream socket implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Get a socket option. |
|
|
Perform an IO control command on the socket. |
|
|
Determine whether the socket is open. |
|
|
Get the local endpoint. |
|
|
Move-assign from another stream socket implementation. |
|
|
Move-construct a new stream socket implementation. |
|
|
(Deprecated: Use native_handle().) Get the native socket implementation. |
|
|
Get the native socket implementation. |
|
|
Gets the non-blocking mode of the native socket implementation. Sets the non-blocking mode of the native socket implementation. |
|
|
Gets the non-blocking mode of the socket. Sets the non-blocking mode of the socket. |
|
|
Open a stream socket. |
|
|
Receive some data from the peer. |
|
|
Get the remote endpoint. |
|
|
Send the given data to the peer. |
|
|
Set a socket option. |
|
|
Disable sends or receives on the socket. |
|
|
Construct a new stream socket service for the specified io_service. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/stream_socket_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native socket to a stream socket.
boost::system::error_code assign( implementation_type & impl, const protocol_type & protocol, const native_handle_type & native_socket, boost::system::error_code & ec);
Start an asynchronous connect.
template< typename ConnectHandler> void-or-deduced async_connect( implementation_type & impl, const endpoint_type & peer_endpoint, ConnectHandler handler);
Start an asynchronous receive.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, WriteHandler handler);
Determine whether the socket is at the out-of-band data mark.
bool at_mark( const implementation_type & impl, boost::system::error_code & ec) const;
Determine the number of bytes available for reading.
std::size_t available( const implementation_type & impl, boost::system::error_code & ec) const;
Bind the stream socket to the specified local endpoint.
boost::system::error_code bind( implementation_type & impl, const endpoint_type & endpoint, boost::system::error_code & ec);
Cancel all asynchronous operations associated with the socket.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a stream socket implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Connect the stream socket to the specified endpoint.
boost::system::error_code connect( implementation_type & impl, const endpoint_type & peer_endpoint, boost::system::error_code & ec);
Move-construct a new stream socket implementation from another protocol type.
template< typename Protocol1> void converting_move_construct( implementation_type & impl, typename stream_socket_service< Protocol1 >::implementation_type & other_impl, typename enable_if< is_convertible< Protocol1, Protocol >::value >::type * = 0);
typedef Protocol::endpoint endpoint_type;
Header: boost/asio/stream_socket_service.hpp
Convenience header: boost/asio.hpp
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
template< typename GettableSocketOption> boost::system::error_code get_option( const implementation_type & impl, GettableSocketOption & option, boost::system::error_code & ec) const;
The type of a stream socket implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/stream_socket_service.hpp
Convenience header: boost/asio.hpp
Perform an IO control command on the socket.
template< typename IoControlCommand> boost::system::error_code io_control( implementation_type & impl, IoControlCommand & command, boost::system::error_code & ec);
endpoint_type local_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Move-assign from another stream socket implementation.
void move_assign( implementation_type & impl, stream_socket_service & other_service, implementation_type & other_impl);
Move-construct a new stream socket implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native socket implementation.
native_type native( implementation_type & impl);
Get the native socket implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/stream_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the native socket implementation.
bool native_non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the native socket implementation.
boost::system::error_code native_non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
(Deprecated: Use native_handle_type.) The native socket type.
typedef implementation_defined native_type;
Header: boost/asio/stream_socket_service.hpp
Convenience header: boost/asio.hpp
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const; » more...
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec); » more...
Gets the non-blocking mode of the socket.
bool non_blocking( const implementation_type & impl) const;
Sets the non-blocking mode of the socket.
boost::system::error_code non_blocking( implementation_type & impl, bool mode, boost::system::error_code & ec);
boost::system::error_code open( implementation_type & impl, const protocol_type & protocol, boost::system::error_code & ec);
typedef Protocol protocol_type;
Header: boost/asio/stream_socket_service.hpp
Convenience header: boost/asio.hpp
Receive some data from the peer.
template< typename MutableBufferSequence> std::size_t receive( implementation_type & impl, const MutableBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
endpoint_type remote_endpoint( const implementation_type & impl, boost::system::error_code & ec) const;
Send the given data to the peer.
template< typename ConstBufferSequence> std::size_t send( implementation_type & impl, const ConstBufferSequence & buffers, socket_base::message_flags flags, boost::system::error_code & ec);
template< typename SettableSocketOption> boost::system::error_code set_option( implementation_type & impl, const SettableSocketOption & option, boost::system::error_code & ec);
Disable sends or receives on the socket.
boost::system::error_code shutdown( implementation_type & impl, socket_base::shutdown_type what, boost::system::error_code & ec);
Construct a new stream socket
service for the specified io_service.
stream_socket_service( boost::asio::io_service & io_service);
Typedef for the typical usage of basic_streambuf.
typedef basic_streambuf streambuf;
|
Name |
Description |
|---|---|
|
The type used to represent the input sequence as a list of buffers. |
|
|
The type used to represent the output sequence as a list of buffers. |
|
Name |
Description |
|---|---|
|
Construct a basic_streambuf object. |
|
|
Move characters from the output sequence to the input sequence. |
|
|
Remove characters from the input sequence. |
|
|
Get a list of buffers that represents the input sequence. |
|
|
Get the maximum size of the basic_streambuf. |
|
|
Get a list of buffers that represents the output sequence, with the given size. |
|
|
Get the size of the input sequence. |
|
Name |
Description |
|---|---|
|
Override std::streambuf behaviour. |
|
|
Override std::streambuf behaviour. |
The basic_streambuf class
is derived from std::streambuf to associate the streambuf's
input and output sequences with one or more character arrays. These character
arrays are internal to the basic_streambuf
object, but direct access to the array elements is provided to permit them
to be used efficiently with I/O operations. Characters written to the output
sequence of a basic_streambuf
object are appended to the input sequence of the same object.
The basic_streambuf class's
public interface is intended to permit the following implementation strategies:
The constructor for basic_streambuf accepts a size_t argument specifying the maximum
of the sum of the sizes of the input sequence and output sequence. During
the lifetime of the basic_streambuf
object, the following invariant holds:
size() <= max_size()
Any member function that would, if successful, cause the invariant to be
violated shall throw an exception of class std::length_error.
The constructor for basic_streambuf
takes an Allocator argument. A copy of this argument is used for any memory
allocation performed, by the constructor and by all member functions, during
the lifetime of each basic_streambuf
object.
Writing directly from an streambuf to a socket:
boost::asio::streambuf b; std::ostream os(&b); os << "Hello, World!\n"; // try sending some data in input sequence size_t n = sock.send(b.data()); b.consume(n); // sent data is removed from input sequence
Reading from a socket directly into a streambuf:
boost::asio::streambuf b; // reserve 512 bytes in output sequence boost::asio::streambuf::mutable_buffers_type bufs = b.prepare(512); size_t n = sock.receive(bufs); // received data is "committed" from output sequence to input sequence b.commit(n); std::istream is(&b); std::string s; is >> s;
Header: boost/asio/streambuf.hpp
Convenience header: boost/asio.hpp
Typedef for a timer based on the system clock.
typedef basic_waitable_timer< chrono::system_clock > system_timer;
|
Name |
Description |
|---|---|
|
The clock type. |
|
|
The duration type of the clock. |
|
|
The underlying implementation type of I/O object. |
|
|
The type of the service that will be used to provide I/O operations. |
|
|
The time point type of the clock. |
|
|
The wait traits type. |
|
Name |
Description |
|---|---|
|
Start an asynchronous wait on the timer. |
|
|
Constructor. Constructor to set a particular expiry time as an absolute time. Constructor to set a particular expiry time relative to now. |
|
|
Cancel any asynchronous operations that are waiting on the timer. |
|
|
Cancels one asynchronous operation that is waiting on the timer. |
|
|
Get the timer's expiry time as an absolute time. Set the timer's expiry time as an absolute time. |
|
|
Get the timer's expiry time relative to now. Set the timer's expiry time relative to now. |
|
|
Get the io_service associated with the object. |
|
|
Perform a blocking wait on the timer. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The basic_waitable_timer class template
provides the ability to perform a blocking or asynchronous wait for a timer
to expire.
A waitable timer is always in one of two states: "expired" or "not
expired". If the wait() or async_wait() function is called on an expired timer,
the wait operation will complete immediately.
Most applications will use one of the steady_timer, system_timer or high_resolution_timer typedefs.
This waitable timer functionality is for use with the C++11 standard library's
<chrono> facility, or with the Boost.Chrono library.
Distinct objects: Safe.
Shared objects: Unsafe.
Performing a blocking wait (C++11):
// Construct a timer without setting an expiry time. boost::asio::steady_timer timer(io_service); // Set an expiry time relative to now. timer.expires_from_now(std::chrono::seconds(5)); // Wait for the timer to expire. timer.wait();
Performing an asynchronous wait (C++11):
void handler(const boost::system::error_code& error) { if (!error) { // Timer expired. } } ... // Construct a timer with an absolute expiry time. boost::asio::steady_timer timer(io_service, std::chrono::steady_clock::now() + std::chrono::seconds(60)); // Start an asynchronous wait. timer.async_wait(handler);
Changing the expiry time of a timer while there are pending asynchronous waits causes those wait operations to be cancelled. To ensure that the action associated with the timer is performed only once, use something like this: used:
void on_some_event() { if (my_timer.expires_from_now(seconds(5)) > 0) { // We managed to cancel the timer. Start new asynchronous wait. my_timer.async_wait(on_timeout); } else { // Too late, timer has already expired! } } void on_timeout(const boost::system::error_code& e) { if (e != boost::asio::error::operation_aborted) { // Timer was not cancelled, take necessary action. } }
boost::asio::basic_waitable_timer::expires_from_now()
function cancels any pending asynchronous waits, and returns the number
of asynchronous waits that were cancelled. If it returns 0 then you were
too late and the wait handler has already been executed, or will soon
be executed. If it returns 1 then the wait handler was successfully cancelled.
boost::asio::error::operation_aborted.
This typedef uses the C++11 <chrono>
standard library facility, if available. Otherwise, it may use the Boost.Chrono
library. To explicitly utilise Boost.Chrono, use the basic_waitable_timer template directly:
typedef basic_waitable_timer<boost::chrono::system_clock> timer;
Header: boost/asio/system_timer.hpp
Convenience header: None
Time traits specialised for posix_time.
template<> struct time_traits< boost::posix_time::ptime >
|
Name |
Description |
|---|---|
|
The duration type. |
|
|
The time type. |
|
Name |
Description |
|---|---|
|
Add a duration to a time. |
|
|
Test whether one time is less than another. |
|
|
Get the current time. |
|
|
Subtract one time from another. |
|
|
Convert to POSIX duration type. |
Header: boost/asio/time_traits.hpp
Convenience header: boost/asio.hpp
static time_type add( const time_type & t, const duration_type & d);
typedef boost::posix_time::time_duration duration_type;
Header: boost/asio/time_traits.hpp
Convenience header: boost/asio.hpp
Test whether one time is less than another.
static bool less_than( const time_type & t1, const time_type & t2);
Subtract one time from another.
static duration_type subtract( const time_type & t1, const time_type & t2);
typedef boost::posix_time::ptime time_type;
Header: boost/asio/time_traits.hpp
Convenience header: boost/asio.hpp
Return a completion condition function object that indicates that a read or write operation should continue until all of the data has been transferred, or until an error occurs.
unspecified transfer_all();
This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.
Reading until a buffer is full:
boost::array<char, 128> buf; boost::system::error_code ec; std::size_t n = boost::asio::read( sock, boost::asio::buffer(buf), boost::asio::transfer_all(), ec); if (ec) { // An error occurred. } else { // n == 128 }
Header: boost/asio/completion_condition.hpp
Convenience header: boost/asio.hpp
Return a completion condition function object that indicates that a read or write operation should continue until a minimum number of bytes has been transferred, or until an error occurs.
unspecified transfer_at_least( std::size_t minimum);
This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.
Reading until a buffer is full or contains at least 64 bytes:
boost::array<char, 128> buf; boost::system::error_code ec; std::size_t n = boost::asio::read( sock, boost::asio::buffer(buf), boost::asio::transfer_at_least(64), ec); if (ec) { // An error occurred. } else { // n >= 64 && n <= 128 }
Header: boost/asio/completion_condition.hpp
Convenience header: boost/asio.hpp
Return a completion condition function object that indicates that a read or write operation should continue until an exact number of bytes has been transferred, or until an error occurs.
unspecified transfer_exactly( std::size_t size);
This function is used to create an object, of unspecified type, that meets CompletionCondition requirements.
Reading until a buffer is full or contains exactly 64 bytes:
boost::array<char, 128> buf; boost::system::error_code ec; std::size_t n = boost::asio::read( sock, boost::asio::buffer(buf), boost::asio::transfer_exactly(64), ec); if (ec) { // An error occurred. } else { // n == 64 }
Header: boost/asio/completion_condition.hpp
Convenience header: boost/asio.hpp
A special value, similar to std::nothrow.
constexpr use_future_t use_future;
See the documentation for use_future_t for a usage example.
Header: boost/asio/use_future.hpp
Convenience header: None
Class used to specify that an asynchronous operation should return a future.
template< typename Allocator = std::allocator<void>> class use_future_t
|
Name |
Description |
|---|---|
|
The allocator type. The allocator is used when constructing the std::promise object for a given asynchronous operation. |
|
Name |
Description |
|---|---|
|
Obtain allocator. |
|
|
Specify an alternate allocator. |
|
|
Construct using default-constructed allocator. Construct using specified allocator. |
The use_future_t
class is used to indicate that an asynchronous operation should return a
std::future object. A use_future_t object may be passed
as a handler to an asynchronous operation, typically using the special value
boost::asio::use_future. For example:
std::future<std::size_t> my_future = my_socket.async_read_some(my_buffer, boost::asio::use_future);
The initiating function (async_read_some in the above example) returns a future that will receive the result of the operation. If the operation completes with an error_code indicating failure, it is converted into a system_error and passed back to the caller via the future.
Header: boost/asio/use_future.hpp
Convenience header: None
The allocator type. The allocator is used when
constructing the std::promise object for a given asynchronous
operation.
typedef Allocator allocator_type;
Header: boost/asio/use_future.hpp
Convenience header: None
Specify an alternate allocator.
template< typename OtherAllocator> use_future_t< OtherAllocator > operator[]( const OtherAllocator & allocator) const;
Construct using default-constructed allocator.
constexpr use_future_t(); » more...
Construct using specified allocator.
explicit use_future_t( const Allocator & allocator); » more...
Construct using default-constructed allocator.
constexpr use_future_t();
Construct using specified allocator.
use_future_t( const Allocator & allocator);
template< typename Service> Service & use_service( io_service & ios);
This function is used to locate a service object that corresponds to the
given service type. If there is no existing implementation of the service,
then the io_service
will create a new instance of the service.
The io_service
object that owns the service.
The service interface implementing the specified service type. Ownership of the service interface is not transferred to the caller.
Header: boost/asio/io_service.hpp
Convenience header: boost/asio.hpp
Wait traits suitable for use with the basic_waitable_timer class template.
template< typename Clock> struct wait_traits
|
Name |
Description |
|---|---|
|
Convert a clock duration into a duration used for waiting. |
Header: boost/asio/wait_traits.hpp
Convenience header: boost/asio.hpp
Convert a clock duration into a duration used for waiting.
static Clock::duration to_wait_duration( const typename Clock::duration & d);
d.
Default service implementation for a timer.
template< typename Clock, typename WaitTraits = boost::asio::wait_traits<Clock>> class waitable_timer_service : public io_service::service
|
Name |
Description |
|---|---|
|
The clock type. |
|
|
The duration type of the clock. |
|
|
The implementation type of the waitable timer. |
|
|
The time point type of the clock. |
|
|
The wait traits type. |
|
Name |
Description |
|---|---|
|
Cancel any asynchronous wait operations associated with the timer. |
|
|
Cancels one asynchronous wait operation associated with the timer. |
|
|
Construct a new timer implementation. |
|
|
Destroy a timer implementation. |
|
|
Get the expiry time for the timer as an absolute time. Set the expiry time for the timer as an absolute time. |
|
|
Get the expiry time for the timer relative to now. Set the expiry time for the timer relative to now. |
|
|
Get the io_service object that owns the service. |
|
|
Construct a new timer service for the specified io_service. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/waitable_timer_service.hpp
Convenience header: boost/asio.hpp
template< typename WaitHandler> void-or-deduced async_wait( implementation_type & impl, WaitHandler handler);
Cancel any asynchronous wait operations associated with the timer.
std::size_t cancel( implementation_type & impl, boost::system::error_code & ec);
Cancels one asynchronous wait operation associated with the timer.
std::size_t cancel_one( implementation_type & impl, boost::system::error_code & ec);
typedef Clock clock_type;
Header: boost/asio/waitable_timer_service.hpp
Convenience header: boost/asio.hpp
The duration type of the clock.
typedef clock_type::duration duration;
Header: boost/asio/waitable_timer_service.hpp
Convenience header: boost/asio.hpp
Get the expiry time for the timer as an absolute time.
time_point expires_at( const implementation_type & impl) const; » more...
Set the expiry time for the timer as an absolute time.
std::size_t expires_at( implementation_type & impl, const time_point & expiry_time, boost::system::error_code & ec); » more...
Get the expiry time for the timer as an absolute time.
time_point expires_at( const implementation_type & impl) const;
Set the expiry time for the timer as an absolute time.
std::size_t expires_at( implementation_type & impl, const time_point & expiry_time, boost::system::error_code & ec);
Get the expiry time for the timer relative to now.
duration expires_from_now( const implementation_type & impl) const; » more...
Set the expiry time for the timer relative to now.
std::size_t expires_from_now( implementation_type & impl, const duration & expiry_time, boost::system::error_code & ec); » more...
Get the expiry time for the timer relative to now.
duration expires_from_now( const implementation_type & impl) const;
Set the expiry time for the timer relative to now.
std::size_t expires_from_now( implementation_type & impl, const duration & expiry_time, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The implementation type of the waitable timer.
typedef implementation_defined implementation_type;
Header: boost/asio/waitable_timer_service.hpp
Convenience header: boost/asio.hpp
The time point type of the clock.
typedef clock_type::time_point time_point;
Header: boost/asio/waitable_timer_service.hpp
Convenience header: boost/asio.hpp
typedef WaitTraits traits_type;
Header: boost/asio/waitable_timer_service.hpp
Convenience header: boost/asio.hpp
void wait( implementation_type & impl, boost::system::error_code & ec);
Construct a new timer service
for the specified io_service.
waitable_timer_service( boost::asio::io_service & io_service);
Provides Windows handle functionality.
template< typename HandleService> class basic_handle : public basic_io_object< HandleService >
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Construct a basic_handle without opening it. Construct a basic_handle on an existing native handle. Move-construct a basic_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_handle from another. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_handle class template provides
the ability to wrap a Windows handle.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_handle.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle); » more... boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec); » more...
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle);
Assign an existing native handle to the handle.
boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec);
Construct a windows::basic_handle without opening it.
explicit basic_handle( boost::asio::io_service & io_service); » more...
Construct a windows::basic_handle on an existing native
handle.
basic_handle( boost::asio::io_service & io_service, const native_handle_type & handle); » more...
Move-construct a windows::basic_handle from another.
basic_handle( basic_handle && other); » more...
Construct a windows::basic_handle without opening
it.
basic_handle( boost::asio::io_service & io_service);
This constructor creates a handle without opening it.
The io_service object that
the handle will use to dispatch handlers for any asynchronous operations
performed on the handle.
Construct a windows::basic_handle on an existing
native handle.
basic_handle( boost::asio::io_service & io_service, const native_handle_type & handle);
This constructor creates a handle object to hold an existing native handle.
The io_service object that
the handle will use to dispatch handlers for any asynchronous operations
performed on the handle.
A native handle.
Thrown on failure.
Move-construct a windows::basic_handle from another.
basic_handle( basic_handle && other);
This constructor moves a handle from one object to another.
The other windows::basic_handle object from
which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_handle(io_service&) constructor.
Cancel all asynchronous operations associated with the handle.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Cancel all asynchronous operations associated with the handle.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Close the handle.
void close();
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Thrown on failure.
Close the handle.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().) The underlying implementation of the
I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/windows/basic_handle.hpp
Convenience header: boost/asio.hpp
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
A windows::basic_handle is always the lowest
layer.
typedef basic_handle< HandleService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Construct a basic_handle without opening it. Construct a basic_handle on an existing native handle. Move-construct a basic_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_handle from another. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_handle class template provides
the ability to wrap a Windows handle.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_handle.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle().) Get the native handle representation.
native_type native();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
Get the native handle representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
The native representation of a handle.
typedef HandleService::native_handle_type native_handle_type;
Header: boost/asio/windows/basic_handle.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native representation of a handle.
typedef HandleService::native_handle_type native_type;
Header: boost/asio/windows/basic_handle.hpp
Convenience header: boost/asio.hpp
Move-assign a windows::basic_handle from another.
basic_handle & operator=( basic_handle && other);
This assignment operator moves a handle from one object to another.
The other windows::basic_handle object from
which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_handle(io_service&) constructor.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef HandleService service_type;
Header: boost/asio/windows/basic_handle.hpp
Convenience header: boost/asio.hpp
Provides object-oriented handle functionality.
template< typename ObjectHandleService = object_handle_service> class basic_object_handle : public windows::basic_handle< ObjectHandleService >
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Start an asynchronous wait on the object handle. |
|
|
Construct a basic_object_handle without opening it. Construct a basic_object_handle on an existing native handle. Move-construct a basic_object_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_object_handle from another. |
|
|
Perform a blocking wait on the object handle. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_object_handle class template
provides asynchronous and blocking object-oriented handle functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_object_handle.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle); » more... boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle);
Inherited from windows::basic_handle.
Assign an existing native handle to the handle.
boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec);
Start an asynchronous wait on the object handle.
template< typename WaitHandler> void-or-deduced async_wait( WaitHandler handler);
This function is be used to initiate an asynchronous wait against the object handle. It always returns immediately.
The handler to be called when the object handle is set to the signalled state. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error // Result of operation. );
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().
Construct a windows::basic_object_handle without opening
it.
explicit basic_object_handle( boost::asio::io_service & io_service); » more...
Construct a windows::basic_object_handle on an existing
native handle.
basic_object_handle( boost::asio::io_service & io_service, const native_handle_type & native_handle); » more...
Move-construct a windows::basic_object_handle from another.
basic_object_handle( basic_object_handle && other); » more...
Construct a windows::basic_object_handle without
opening it.
basic_object_handle( boost::asio::io_service & io_service);
This constructor creates an object handle without opening it.
The io_service object that
the object handle will use to dispatch handlers for any asynchronous
operations performed on the handle.
Construct a windows::basic_object_handle on an existing
native handle.
basic_object_handle( boost::asio::io_service & io_service, const native_handle_type & native_handle);
This constructor creates an object handle object to hold an existing native handle.
The io_service object that
the object handle will use to dispatch handlers for any asynchronous
operations performed on the handle.
The new underlying handle implementation.
Thrown on failure.
Move-construct a windows::basic_object_handle from another.
basic_object_handle( basic_object_handle && other);
This constructor moves an object handle from one object to another.
The other windows::basic_object_handle object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_object_handle(io_service&) constructor.
Cancel all asynchronous operations associated with the handle.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Cancel all asynchronous operations associated with the handle.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from windows::basic_handle.
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Close the handle.
void close();
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from windows::basic_handle.
Close the handle.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().)
The underlying implementation of the I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/windows/basic_object_handle.hpp
Convenience header: boost/asio.hpp
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from windows::basic_handle.
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from windows::basic_handle.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from windows::basic_handle.
A windows::basic_handle is always the lowest
layer.
typedef basic_handle< ObjectHandleService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Construct a basic_handle without opening it. Construct a basic_handle on an existing native handle. Move-construct a basic_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_handle from another. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_handle class template provides
the ability to wrap a Windows handle.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_object_handle.hpp
Convenience header: boost/asio.hpp
Inherited from windows::basic_handle.
(Deprecated: Use native_handle().) Get the native handle representation.
native_type native();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
Inherited from windows::basic_handle.
Get the native handle representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
The native representation of a handle.
typedef ObjectHandleService::native_handle_type native_handle_type;
Header: boost/asio/windows/basic_object_handle.hpp
Convenience header: boost/asio.hpp
Inherited from windows::basic_handle.
(Deprecated: Use native_handle_type.) The native representation of a handle.
typedef ObjectHandleService::native_handle_type native_type;
Header: boost/asio/windows/basic_object_handle.hpp
Convenience header: boost/asio.hpp
Move-assign a windows::basic_object_handle from another.
basic_object_handle & operator=( basic_object_handle && other);
This assignment operator moves an object handle from one object to another.
The other windows::basic_object_handle object
from which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_object_handle(io_service&) constructor.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef ObjectHandleService service_type;
Header: boost/asio/windows/basic_object_handle.hpp
Convenience header: boost/asio.hpp
Perform a blocking wait on the object handle.
void wait(); » more... void wait( boost::system::error_code & ec); » more...
Perform a blocking wait on the object handle.
void wait();
This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
Thrown on failure.
Perform a blocking wait on the object handle.
void wait( boost::system::error_code & ec);
This function is used to wait for the object handle to be set to the signalled state. This function blocks and does not return until the object handle has been set to the signalled state.
Set to indicate what error occurred, if any.
Provides random-access handle functionality.
template< typename RandomAccessHandleService = random_access_handle_service> class basic_random_access_handle : public windows::basic_handle< RandomAccessHandleService >
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Start an asynchronous read at the specified offset. |
|
|
Start an asynchronous write at the specified offset. |
|
|
Construct a basic_random_access_handle without opening it. Construct a basic_random_access_handle on an existing native handle. Move-construct a basic_random_access_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_random_access_handle from another. |
|
|
Read some data from the handle at the specified offset. |
|
|
Write some data to the handle at the specified offset. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_random_access_handle class
template provides asynchronous and blocking random-access handle functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_random_access_handle.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle); » more... boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle);
Inherited from windows::basic_handle.
Assign an existing native handle to the handle.
boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec);
Start an asynchronous read at the specified offset.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some_at( uint64_t offset, const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read data from the random-access handle. The function call always returns immediately.
The offset at which the data will be read.
One or more buffers into which the data will be read. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. );
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().
The read operation may not read all of the requested number of bytes. Consider
using the async_read_at function if you
need to ensure that the requested amount of data is read before the asynchronous
operation completes.
To read into a single data buffer use the buffer function as follows:
handle.async_read_some_at(42, boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Start an asynchronous write at the specified offset.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some_at( uint64_t offset, const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write data to the random-access handle. The function call always returns immediately.
The offset at which the data will be written.
One or more data buffers to be written to the handle. 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. );
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().
The write operation may not transmit all of the data to the peer. Consider
using the async_write_at function if you
need to ensure that all data is written before the asynchronous operation
completes.
To write a single data buffer use the buffer function as follows:
handle.async_write_some_at(42, boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Construct
a windows::basic_random_access_handle without
opening it.
explicit basic_random_access_handle( boost::asio::io_service & io_service); » more...
Construct a windows::basic_random_access_handle on
an existing native handle.
basic_random_access_handle( boost::asio::io_service & io_service, const native_handle_type & handle); » more...
Move-construct a windows::basic_random_access_handle from
another.
basic_random_access_handle( basic_random_access_handle && other); » more...
Construct a windows::basic_random_access_handle without
opening it.
basic_random_access_handle( boost::asio::io_service & io_service);
This constructor creates a random-access handle without opening it. The handle needs to be opened before data can be written to or read from it.
The io_service object that
the random-access handle will use to dispatch handlers for any
asynchronous operations performed on the handle.
Construct a windows::basic_random_access_handle on
an existing native handle.
basic_random_access_handle( boost::asio::io_service & io_service, const native_handle_type & handle);
This constructor creates a random-access handle object to hold an existing native handle.
The io_service object that
the random-access handle will use to dispatch handlers for any
asynchronous operations performed on the handle.
The new underlying handle implementation.
Thrown on failure.
Move-construct a windows::basic_random_access_handle from
another.
basic_random_access_handle( basic_random_access_handle && other);
This constructor moves a random-access handle from one object to another.
The other windows::basic_random_access_handle
object from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_random_access_handle(io_service&) constructor.
Cancel all asynchronous operations associated with the handle.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Cancel all asynchronous operations associated with the handle.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from windows::basic_handle.
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Close the handle.
void close();
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from windows::basic_handle.
Close the handle.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().)
The underlying implementation of the I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/windows/basic_random_access_handle.hpp
Convenience header: boost/asio.hpp
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from windows::basic_handle.
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from windows::basic_handle.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from windows::basic_handle.
A windows::basic_handle is always the lowest
layer.
typedef basic_handle< RandomAccessHandleService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Construct a basic_handle without opening it. Construct a basic_handle on an existing native handle. Move-construct a basic_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_handle from another. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_handle class template provides
the ability to wrap a Windows handle.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_random_access_handle.hpp
Convenience header: boost/asio.hpp
Inherited from windows::basic_handle.
(Deprecated: Use native_handle().)
Get the native handle representation.
native_type native();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
Inherited from windows::basic_handle.
Get the native handle representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
The native representation of a handle.
typedef RandomAccessHandleService::native_handle_type native_handle_type;
Header: boost/asio/windows/basic_random_access_handle.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native representation of a handle.
typedef RandomAccessHandleService::native_handle_type native_type;
Header: boost/asio/windows/basic_random_access_handle.hpp
Convenience header: boost/asio.hpp
Move-assign a windows::basic_random_access_handle from
another.
basic_random_access_handle & operator=( basic_random_access_handle && other);
This assignment operator moves a random-access handle from one object to another.
The other windows::basic_random_access_handle
object from which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_random_access_handle(io_service&) constructor.
Read some data from the handle at the specified offset.
template< typename MutableBufferSequence> std::size_t read_some_at( uint64_t offset, const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t read_some_at( uint64_t offset, const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the handle at the specified offset.
template< typename MutableBufferSequence> std::size_t read_some_at( uint64_t offset, const MutableBufferSequence & buffers);
This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
The offset at which the data will be read.
One or more buffers into which the data will be read.
The number of bytes read.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The read_some operation may not read all of the requested number of bytes.
Consider using the read_at function if you need
to ensure that the requested amount of data is read before the blocking
operation completes.
To read into a single data buffer use the buffer function as follows:
handle.read_some_at(42, boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Read some data from the handle at the specified offset.
template< typename MutableBufferSequence> std::size_t read_some_at( uint64_t offset, const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read data from the random-access handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
The offset at which the data will be read.
One or more buffers into which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes read. Returns 0 if an error occurred.
The read_some operation may not read all of the requested number of bytes.
Consider using the read_at function if you need
to ensure that the requested amount of data is read before the blocking
operation completes.
Inherited from basic_io_object.
(Deprecated: Use get_service().)
The service associated with the I/O object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef RandomAccessHandleService service_type;
Header: boost/asio/windows/basic_random_access_handle.hpp
Convenience header: boost/asio.hpp
Write some data to the handle at the specified offset.
template< typename ConstBufferSequence> std::size_t write_some_at( uint64_t offset, const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t write_some_at( uint64_t offset, const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write some data to the handle at the specified offset.
template< typename ConstBufferSequence> std::size_t write_some_at( uint64_t offset, const ConstBufferSequence & buffers);
This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
The offset at which the data will be written.
One or more data buffers to be written to the handle.
The number of bytes written.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The write_some_at operation may not write all of the data. Consider using
the write_at
function if you need to ensure that all data is written before the blocking
operation completes.
To write a single data buffer use the buffer function as follows:
handle.write_some_at(42, boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Write some data to the handle at the specified offset.
template< typename ConstBufferSequence> std::size_t write_some_at( uint64_t offset, const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write data to the random-access handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
The offset at which the data will be written.
One or more data buffers to be written to the handle.
Set to indicate what error occurred, if any.
The number of bytes written. Returns 0 if an error occurred.
The write_some operation may not transmit all of the data to the peer.
Consider using the write_at function if you need
to ensure that all data is written before the blocking operation completes.
Provides stream-oriented handle functionality.
template< typename StreamHandleService = stream_handle_service> class basic_stream_handle : public windows::basic_handle< StreamHandleService >
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_stream_handle without opening it. Construct a basic_stream_handle on an existing native handle. Move-construct a basic_stream_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_stream_handle from another. |
|
|
Read some data from the handle. |
|
|
Write some data to the handle. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_stream_handle class template
provides asynchronous and blocking stream-oriented handle functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_stream_handle.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle); » more... boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Assign an existing native handle to the handle.
void assign( const native_handle_type & handle);
Inherited from windows::basic_handle.
Assign an existing native handle to the handle.
boost::system::error_code assign( const native_handle_type & handle, boost::system::error_code & ec);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( const MutableBufferSequence & buffers, ReadHandler handler);
This function is used to asynchronously read data from the stream handle. The function call always returns immediately.
One or more buffers into which the data will be read. 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.
The handler to be called when the read operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. );
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().
The read operation may not read all of the requested number of bytes. Consider
using the async_read function if you need
to ensure that the requested amount of data is read before the asynchronous
operation completes.
To read into a single data buffer use the buffer function as follows:
handle.async_read_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on reading into multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( const ConstBufferSequence & buffers, WriteHandler handler);
This function is used to asynchronously write data to the stream handle. The function call always returns immediately.
One or more data buffers to be written to the handle. 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.
The handler to be called when the write operation completes. Copies will be made of the handler as required. The function signature of the handler must be:
void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. );
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().
The write operation may not transmit all of the data to the peer. Consider
using the async_write function if you need
to ensure that all data is written before the asynchronous operation completes.
To write a single data buffer use the buffer function as follows:
handle.async_write_some(boost::asio::buffer(data, size), handler);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Construct a windows::basic_stream_handle without opening
it.
explicit basic_stream_handle( boost::asio::io_service & io_service); » more...
Construct a windows::basic_stream_handle on an existing
native handle.
basic_stream_handle( boost::asio::io_service & io_service, const native_handle_type & handle); » more...
Move-construct a windows::basic_stream_handle from another.
basic_stream_handle( basic_stream_handle && other); » more...
Construct a windows::basic_stream_handle without
opening it.
basic_stream_handle( boost::asio::io_service & io_service);
This constructor creates a stream handle without opening it. The handle needs to be opened and then connected or accepted before data can be sent or received on it.
The io_service object that
the stream handle will use to dispatch handlers for any asynchronous
operations performed on the handle.
Construct a windows::basic_stream_handle on an existing
native handle.
basic_stream_handle( boost::asio::io_service & io_service, const native_handle_type & handle);
This constructor creates a stream handle object to hold an existing native handle.
The io_service object that
the stream handle will use to dispatch handlers for any asynchronous
operations performed on the handle.
The new underlying handle implementation.
Thrown on failure.
Move-construct a windows::basic_stream_handle from another.
basic_stream_handle( basic_stream_handle && other);
This constructor moves a stream handle from one object to another.
The other windows::basic_stream_handle object
from which the move will occur.
Following the move, the moved-from object is in the same state as if
constructed using the basic_stream_handle(io_service&) constructor.
Cancel all asynchronous operations associated with the handle.
void cancel(); » more... boost::system::error_code cancel( boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Cancel all asynchronous operations associated with the handle.
void cancel();
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from windows::basic_handle.
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( boost::system::error_code & ec);
This function causes all outstanding asynchronous read or write operations
to finish immediately, and the handlers for cancelled operations will
be passed the boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
void close(); » more... boost::system::error_code close( boost::system::error_code & ec); » more...
Inherited from windows::basic_handle.
Close the handle.
void close();
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Thrown on failure.
Inherited from windows::basic_handle.
Close the handle.
boost::system::error_code close( boost::system::error_code & ec);
This function is used to close the handle. Any asynchronous read or write
operations will be cancelled immediately, and will complete with the
boost::asio::error::operation_aborted error.
Set to indicate what error occurred, if any.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation(); » more... const implementation_type & get_implementation() const; » more...
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
implementation_type & get_implementation();
Inherited from basic_io_object.
Get the underlying implementation of the I/O object.
const implementation_type & get_implementation() const;
Inherited from basic_io_object.
Get the io_service associated with the
object.
boost::asio::io_service & get_io_service();
This function may be used to obtain the io_service object that the I/O
object uses to dispatch handlers for asynchronous operations.
A reference to the io_service object that the I/O
object will use to dispatch handlers. Ownership is not transferred to the
caller.
Get the service associated with the I/O object.
service_type & get_service(); » more... const service_type & get_service() const; » more...
Inherited from basic_io_object.
Get the service associated with the I/O object.
service_type & get_service();
Inherited from basic_io_object.
Get the service associated with the I/O object.
const service_type & get_service() const;
Inherited from basic_io_object.
(Deprecated: Use get_implementation().)
The underlying implementation of the I/O object.
implementation_type implementation;
Inherited from basic_io_object.
The underlying implementation type of I/O object.
typedef service_type::implementation_type implementation_type;
Header: boost/asio/windows/basic_stream_handle.hpp
Convenience header: boost/asio.hpp
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer(); » more...
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const; » more...
Inherited from windows::basic_handle.
Get a reference to the lowest layer.
lowest_layer_type & lowest_layer();
This function returns a reference to the lowest layer in a stack of layers.
Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from windows::basic_handle.
Get a const reference to the lowest layer.
const lowest_layer_type & lowest_layer() const;
This function returns a const reference to the lowest layer in a stack
of layers. Since a windows::basic_handle cannot contain
any further layers, it simply returns a reference to itself.
A const reference to the lowest layer in the stack of layers. Ownership is not transferred to the caller.
Inherited from windows::basic_handle.
A windows::basic_handle is always the lowest
layer.
typedef basic_handle< StreamHandleService > lowest_layer_type;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Construct a basic_handle without opening it. Construct a basic_handle on an existing native handle. Move-construct a basic_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_handle from another. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
|
Protected destructor to prevent deletion through this type. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_handle class template provides
the ability to wrap a Windows handle.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/basic_stream_handle.hpp
Convenience header: boost/asio.hpp
Inherited from windows::basic_handle.
(Deprecated: Use native_handle().) Get the native handle representation.
native_type native();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
Inherited from windows::basic_handle.
Get the native handle representation.
native_handle_type native_handle();
This function may be used to obtain the underlying representation of the handle. This is intended to allow access to native handle functionality that is not otherwise provided.
The native representation of a handle.
typedef StreamHandleService::native_handle_type native_handle_type;
Header: boost/asio/windows/basic_stream_handle.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native representation of a handle.
typedef StreamHandleService::native_handle_type native_type;
Header: boost/asio/windows/basic_stream_handle.hpp
Convenience header: boost/asio.hpp
Move-assign a windows::basic_stream_handle from another.
basic_stream_handle & operator=( basic_stream_handle && other);
This assignment operator moves a stream handle from one object to another.
The other windows::basic_stream_handle object
from which the move will occur.
Following the move, the moved-from object is in the same state as if constructed
using the basic_stream_handle(io_service&) constructor.
Read some data from the handle.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers); » more... template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec); » more...
Read some data from the handle.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers);
This function is used to read data from the stream handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
The number of bytes read.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
To read into a single data buffer use the buffer function as follows:
handle.read_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on reading into multiple buffers in one
go, and how to use it with arrays, boost::array or std::vector.
Read some data from the handle.
template< typename MutableBufferSequence> std::size_t read_some( const MutableBufferSequence & buffers, boost::system::error_code & ec);
This function is used to read data from the stream handle. The function call will block until one or more bytes of data has been read successfully, or until an error occurs.
One or more buffers into which the data will be read.
Set to indicate what error occurred, if any.
The number of bytes read. Returns 0 if an error occurred.
The read_some operation may not read all of the requested number of bytes.
Consider using the read function if you need to
ensure that the requested amount of data is read before the blocking
operation completes.
Inherited from basic_io_object.
(Deprecated: Use get_service().) The service associated with the I/O
object.
service_type & service;
Available only for services that do not support movability.
Inherited from basic_io_object.
The type of the service that will be used to provide I/O operations.
typedef StreamHandleService service_type;
Header: boost/asio/windows/basic_stream_handle.hpp
Convenience header: boost/asio.hpp
Write some data to the handle.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers); » more... template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec); » more...
Write some data to the handle.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers);
This function is used to write data to the stream handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the handle.
The number of bytes written.
Thrown on failure. An error code of boost::asio::error::eof
indicates that the connection was closed by the peer.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
To write a single data buffer use the buffer function as follows:
handle.write_some(boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go,
and how to use it with arrays, boost::array or std::vector.
Write some data to the handle.
template< typename ConstBufferSequence> std::size_t write_some( const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write data to the stream handle. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs.
One or more data buffers to be written to the handle.
Set to indicate what error occurred, if any.
The number of bytes written. Returns 0 if an error occurred.
The write_some operation may not transmit all of the data to the peer.
Consider using the write function if you need to
ensure that all data is written before the blocking operation completes.
Typedef for the typical usage of an object handle.
typedef basic_object_handle object_handle;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Start an asynchronous wait on the object handle. |
|
|
Construct a basic_object_handle without opening it. Construct a basic_object_handle on an existing native handle. Move-construct a basic_object_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_object_handle from another. |
|
|
Perform a blocking wait on the object handle. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_object_handle class template
provides asynchronous and blocking object-oriented handle functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/object_handle.hpp
Convenience header: boost/asio.hpp
Default service implementation for an object handle.
class object_handle_service : public io_service::service
|
Name |
Description |
|---|---|
|
The type of an object handle implementation. |
|
|
The native handle type. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to an object handle. |
|
|
Start an asynchronous wait. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close an object handle implementation. |
|
|
Construct a new object handle implementation. |
|
|
Destroy an object handle implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Determine whether the handle is open. |
|
|
Move-assign from another object handle implementation. |
|
|
Move-construct a new object handle implementation. |
|
|
Get the native handle implementation. |
|
|
Construct a new object handle service for the specified io_service. |
|
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/windows/object_handle_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to an object handle.
boost::system::error_code assign( implementation_type & impl, const native_handle_type & handle, boost::system::error_code & ec);
template< typename WaitHandler> void-or-deduced async_wait( implementation_type & impl, WaitHandler handler);
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close an object handle implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The type of an object handle implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/windows/object_handle_service.hpp
Convenience header: boost/asio.hpp
Move-assign from another object handle implementation.
void move_assign( implementation_type & impl, object_handle_service & other_service, implementation_type & other_impl);
Move-construct a new object handle implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
Get the native handle implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/windows/object_handle_service.hpp
Convenience header: boost/asio.hpp
Construct a new object
handle service for the specified io_service.
object_handle_service( boost::asio::io_service & io_service);
void wait( implementation_type & impl, boost::system::error_code & ec);
Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
class overlapped_ptr : noncopyable
|
Name |
Description |
|---|---|
|
Post completion notification for overlapped operation. Releases ownership. |
|
|
Get the contained OVERLAPPED object. |
|
|
Construct an empty overlapped_ptr. Construct an overlapped_ptr to contain the specified handler. |
|
|
Release ownership of the OVERLAPPED object. |
|
|
Reset to empty. Reset to contain the specified handler, freeing any current OVERLAPPED object. |
|
|
Destructor automatically frees the OVERLAPPED object unless released. |
A special-purpose smart pointer used to wrap an application handler so that it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/overlapped_ptr.hpp
Convenience header: boost/asio.hpp
Post completion notification for overlapped operation. Releases ownership.
void complete( const boost::system::error_code & ec, std::size_t bytes_transferred);
Get the contained OVERLAPPED object.
OVERLAPPED * get(); » more... const OVERLAPPED * get() const; » more...
Get the contained OVERLAPPED object.
OVERLAPPED * get();
Get the contained OVERLAPPED object.
const OVERLAPPED * get() const;
Construct an empty windows::overlapped_ptr.
overlapped_ptr(); » more...
Construct an windows::overlapped_ptr to contain the
specified handler.
template< typename Handler> explicit overlapped_ptr( boost::asio::io_service & io_service, Handler handler); » more...
Construct an empty windows::overlapped_ptr.
overlapped_ptr();
Construct an windows::overlapped_ptr to contain the
specified handler.
template< typename Handler> overlapped_ptr( boost::asio::io_service & io_service, Handler handler);
void reset(); » more...
Reset to contain the specified handler, freeing any current OVERLAPPED object.
template< typename Handler> void reset( boost::asio::io_service & io_service, Handler handler); » more...
Reset to contain the specified handler, freeing any current OVERLAPPED object.
template< typename Handler> void reset( boost::asio::io_service & io_service, Handler handler);
Typedef for the typical usage of a random-access handle.
typedef basic_random_access_handle random_access_handle;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Start an asynchronous read at the specified offset. |
|
|
Start an asynchronous write at the specified offset. |
|
|
Construct a basic_random_access_handle without opening it. Construct a basic_random_access_handle on an existing native handle. Move-construct a basic_random_access_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_random_access_handle from another. |
|
|
Read some data from the handle at the specified offset. |
|
|
Write some data to the handle at the specified offset. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_random_access_handle class
template provides asynchronous and blocking random-access handle functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/random_access_handle.hpp
Convenience header: boost/asio.hpp
Default service implementation for a random-access handle.
class random_access_handle_service : public io_service::service
|
Name |
Description |
|---|---|
|
The type of a random-access handle implementation. |
|
|
The native handle type. |
|
|
(Deprecated: Use native_handle_type.) The native handle type. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to a random-access handle. |
|
|
Start an asynchronous read at the specified offset. |
|
|
Start an asynchronous write at the specified offset. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close a random-access handle implementation. |
|
|
Construct a new random-access handle implementation. |
|
|
Destroy a random-access handle implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Determine whether the handle is open. |
|
|
Move-assign from another random-access handle implementation. |
|
|
Move-construct a new random-access handle implementation. |
|
|
(Deprecated: Use native_handle().) Get the native handle implementation. |
|
|
Get the native handle implementation. |
|
|
Construct a new random-access handle service for the specified io_service. |
|
|
Read some data from the specified offset. |
|
|
Write the given data at the specified offset. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/windows/random_access_handle_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to a random-access handle.
boost::system::error_code assign( implementation_type & impl, const native_handle_type & handle, boost::system::error_code & ec);
Start an asynchronous read at the specified offset.
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some_at( implementation_type & impl, uint64_t offset, const MutableBufferSequence & buffers, ReadHandler handler);
Start an asynchronous write at the specified offset.
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some_at( implementation_type & impl, uint64_t offset, const ConstBufferSequence & buffers, WriteHandler handler);
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a random-access handle implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The type of a random-access handle implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/windows/random_access_handle_service.hpp
Convenience header: boost/asio.hpp
Move-assign from another random-access handle implementation.
void move_assign( implementation_type & impl, random_access_handle_service & other_service, implementation_type & other_impl);
Move-construct a new random-access handle implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().)
Get the native handle implementation.
native_type native( implementation_type & impl);
Get the native handle implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/windows/random_access_handle_service.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native handle type.
typedef implementation_defined native_type;
Header: boost/asio/windows/random_access_handle_service.hpp
Convenience header: boost/asio.hpp
Construct
a new random-access handle service for the specified io_service.
random_access_handle_service( boost::asio::io_service & io_service);
Read some data from the specified offset.
template< typename MutableBufferSequence> std::size_t read_some_at( implementation_type & impl, uint64_t offset, const MutableBufferSequence & buffers, boost::system::error_code & ec);
Write the given data at the specified offset.
template< typename ConstBufferSequence> std::size_t write_some_at( implementation_type & impl, uint64_t offset, const ConstBufferSequence & buffers, boost::system::error_code & ec);
Typedef for the typical usage of a stream-oriented handle.
typedef basic_stream_handle stream_handle;
|
Name |
Description |
|---|---|
|
The underlying implementation type of I/O object. |
|
|
A basic_handle is always the lowest layer. |
|
|
The native representation of a handle. |
|
|
(Deprecated: Use native_handle_type.) The native representation of a handle. |
|
|
The type of the service that will be used to provide I/O operations. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to the handle. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Construct a basic_stream_handle without opening it. Construct a basic_stream_handle on an existing native handle. Move-construct a basic_stream_handle from another. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close the handle. |
|
|
Get the io_service associated with the object. |
|
|
Determine whether the handle is open. |
|
|
Get a reference to the lowest layer. Get a const reference to the lowest layer. |
|
|
(Deprecated: Use native_handle().) Get the native handle representation. |
|
|
Get the native handle representation. |
|
|
Move-assign a basic_stream_handle from another. |
|
|
Read some data from the handle. |
|
|
Write some data to the handle. |
|
Name |
Description |
|---|---|
|
Get the underlying implementation of the I/O object. |
|
|
Get the service associated with the I/O object. |
|
Name |
Description |
|---|---|
|
(Deprecated: Use get_implementation().) The underlying implementation of the I/O object. |
|
|
(Deprecated: Use get_service().) The service associated with the I/O object. |
The windows::basic_stream_handle class template
provides asynchronous and blocking stream-oriented handle functionality.
Distinct objects: Safe.
Shared objects: Unsafe.
Header: boost/asio/windows/stream_handle.hpp
Convenience header: boost/asio.hpp
Default service implementation for a stream handle.
class stream_handle_service : public io_service::service
|
Name |
Description |
|---|---|
|
The type of a stream handle implementation. |
|
|
The native handle type. |
|
|
(Deprecated: Use native_handle_type.) The native handle type. |
|
Name |
Description |
|---|---|
|
Assign an existing native handle to a stream handle. |
|
|
Start an asynchronous read. |
|
|
Start an asynchronous write. |
|
|
Cancel all asynchronous operations associated with the handle. |
|
|
Close a stream handle implementation. |
|
|
Construct a new stream handle implementation. |
|
|
Destroy a stream handle implementation. |
|
|
Get the io_service object that owns the service. |
|
|
Determine whether the handle is open. |
|
|
Move-assign from another stream handle implementation. |
|
|
Move-construct a new stream handle implementation. |
|
|
(Deprecated: Use native_handle().) Get the native handle implementation. |
|
|
Get the native handle implementation. |
|
|
Read some data from the stream. |
|
|
Construct a new stream handle service for the specified io_service. |
|
|
Write the given data to the stream. |
|
Name |
Description |
|---|---|
|
The unique service identifier. |
Header: boost/asio/windows/stream_handle_service.hpp
Convenience header: boost/asio.hpp
Assign an existing native handle to a stream handle.
boost::system::error_code assign( implementation_type & impl, const native_handle_type & handle, boost::system::error_code & ec);
template< typename MutableBufferSequence, typename ReadHandler> void-or-deduced async_read_some( implementation_type & impl, const MutableBufferSequence & buffers, ReadHandler handler);
template< typename ConstBufferSequence, typename WriteHandler> void-or-deduced async_write_some( implementation_type & impl, const ConstBufferSequence & buffers, WriteHandler handler);
Cancel all asynchronous operations associated with the handle.
boost::system::error_code cancel( implementation_type & impl, boost::system::error_code & ec);
Close a stream handle implementation.
boost::system::error_code close( implementation_type & impl, boost::system::error_code & ec);
Inherited from io_service.
Get the io_service object that owns the
service.
boost::asio::io_service & get_io_service();
The type of a stream handle implementation.
typedef implementation_defined implementation_type;
Header: boost/asio/windows/stream_handle_service.hpp
Convenience header: boost/asio.hpp
Move-assign from another stream handle implementation.
void move_assign( implementation_type & impl, stream_handle_service & other_service, implementation_type & other_impl);
Move-construct a new stream handle implementation.
void move_construct( implementation_type & impl, implementation_type & other_impl);
(Deprecated: Use native_handle().) Get the native handle implementation.
native_type native( implementation_type & impl);
Get the native handle implementation.
native_handle_type native_handle( implementation_type & impl);
typedef implementation_defined native_handle_type;
Header: boost/asio/windows/stream_handle_service.hpp
Convenience header: boost/asio.hpp
(Deprecated: Use native_handle_type.) The native handle type.
typedef implementation_defined native_type;
Header: boost/asio/windows/stream_handle_service.hpp
Convenience header: boost/asio.hpp
Read some data from the stream.
template< typename MutableBufferSequence> std::size_t read_some( implementation_type & impl, const MutableBufferSequence & buffers, boost::system::error_code & ec);
Construct a new stream
handle service for the specified io_service.
stream_handle_service( boost::asio::io_service & io_service);
Write the given data to the stream.
template< typename ConstBufferSequence> std::size_t write_some( implementation_type & impl, const ConstBufferSequence & buffers, boost::system::error_code & ec);
Write a certain amount of data to a stream before returning.
template< typename SyncWriteStream, typename ConstBufferSequence> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers); » more... template< typename SyncWriteStream, typename ConstBufferSequence> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, boost::system::error_code & ec); » more... template< typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition); » more... template< typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec); » more... template< typename SyncWriteStream, typename Allocator> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b); » more... template< typename SyncWriteStream, typename Allocator> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b, boost::system::error_code & ec); » more... template< typename SyncWriteStream, typename Allocator, typename CompletionCondition> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition); » more... template< typename SyncWriteStream, typename Allocator, typename CompletionCondition> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec); » more...
Header: boost/asio/write.hpp
Convenience header: boost/asio.hpp
Write all of the supplied data to a stream before returning.
template< typename SyncWriteStream, typename ConstBufferSequence> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.
The number of bytes transferred.
Thrown on failure.
To write a single data buffer use the buffer function as follows:
boost::asio::write(s, boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::write( s, buffers, boost::asio::transfer_all());
Write all of the supplied data to a stream before returning.
template< typename SyncWriteStream, typename ConstBufferSequence> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.
Set to indicate what error occurred, if any.
The number of bytes transferred.
To write a single data buffer use the buffer function as follows:
boost::asio::write(s, boost::asio::buffer(data, size), ec);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::write( s, buffers, boost::asio::transfer_all(), ec);
Write a certain amount of data to a stream before returning.
template< typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write_some function.
The number of bytes transferred.
Thrown on failure.
To write a single data buffer use the buffer function as follows:
boost::asio::write(s, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32));
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Write a certain amount of data to a stream before returning.
template< typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write( SyncWriteStream & s, const ConstBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the stream.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write_some function.
Set to indicate what error occurred, if any.
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Write all of the supplied data to a stream before returning.
template< typename SyncWriteStream, typename Allocator> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
The basic_streambuf object from
which data will be written.
The number of bytes transferred.
Thrown on failure.
This overload is equivalent to calling:
boost::asio::write( s, b, boost::asio::transfer_all());
Write all of the supplied data to a stream before returning.
template< typename SyncWriteStream, typename Allocator> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
The basic_streambuf object from
which data will be written.
Set to indicate what error occurred, if any.
The number of bytes transferred.
This overload is equivalent to calling:
boost::asio::write( s, b, boost::asio::transfer_all(), ec);
Write a certain amount of data to a stream before returning.
template< typename SyncWriteStream, typename Allocator, typename CompletionCondition> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
The basic_streambuf object from
which data will be written.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write_some function.
The number of bytes transferred.
Thrown on failure.
Write a certain amount of data to a stream before returning.
template< typename SyncWriteStream, typename Allocator, typename CompletionCondition> std::size_t write( SyncWriteStream & s, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a stream. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the stream's write_some function.
The stream to which the data is to be written. The type must support the SyncWriteStream concept.
The basic_streambuf object from
which data will be written.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the stream's write_some function.
Set to indicate what error occurred, if any.
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Write a certain amount of data at a specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers); » more... template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, boost::system::error_code & ec); » more... template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition); » more... template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec); » more... template< typename SyncRandomAccessWriteDevice, typename Allocator> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b); » more... template< typename SyncRandomAccessWriteDevice, typename Allocator> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, boost::system::error_code & ec); » more... template< typename SyncRandomAccessWriteDevice, typename Allocator, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition); » more... template< typename SyncRandomAccessWriteDevice, typename Allocator, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec); » more...
Header: boost/asio/write_at.hpp
Convenience header: boost/asio.hpp
Write all of the supplied data at the specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.
The number of bytes transferred.
Thrown on failure.
To write a single data buffer use the buffer function as follows:
boost::asio::write_at(d, 42, boost::asio::buffer(data, size));
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::write_at( d, offset, buffers, boost::asio::transfer_all());
Write all of the supplied data at the specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.
Set to indicate what error occurred, if any.
The number of bytes transferred.
To write a single data buffer use the buffer function as follows:
boost::asio::write_at(d, 42, boost::asio::buffer(data, size), ec);
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
This overload is equivalent to calling:
boost::asio::write_at( d, offset, buffers, boost::asio::transfer_all(), ec);
Write a certain amount of data at a specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write_some_at function.
The number of bytes transferred.
Thrown on failure.
To write a single data buffer use the buffer function as follows:
boost::asio::write_at(d, 42, boost::asio::buffer(data, size), boost::asio::transfer_at_least(32));
See the buffer
documentation for information on writing multiple buffers in one go, and
how to use it with arrays, boost::array or std::vector.
Write a certain amount of data at a specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename ConstBufferSequence, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, const ConstBufferSequence & buffers, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
One or more buffers containing the data to be written. The sum of the buffer sizes indicates the maximum number of bytes to write to the device.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write_some_at function.
Set to indicate what error occurred, if any.
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Write all of the supplied data at the specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename Allocator> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
The basic_streambuf object from
which data will be written.
The number of bytes transferred.
Thrown on failure.
This overload is equivalent to calling:
boost::asio::write_at( d, 42, b, boost::asio::transfer_all());
Write all of the supplied data at the specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename Allocator> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
The basic_streambuf object from
which data will be written.
Set to indicate what error occurred, if any.
The number of bytes transferred.
This overload is equivalent to calling:
boost::asio::write_at( d, 42, b, boost::asio::transfer_all(), ec);
Write a certain amount of data at a specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename Allocator, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
The basic_streambuf object from
which data will be written.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write_some_at function.
The number of bytes transferred.
Thrown on failure.
Write a certain amount of data at a specified offset before returning.
template< typename SyncRandomAccessWriteDevice, typename Allocator, typename CompletionCondition> std::size_t write_at( SyncRandomAccessWriteDevice & d, uint64_t offset, basic_streambuf< Allocator > & b, CompletionCondition completion_condition, boost::system::error_code & ec);
This function is used to write a certain number of bytes of data to a random access device at a specified offset. The call will block until one of the following conditions is true:
basic_streambuf has been written.
This operation is implemented in terms of zero or more calls to the device's write_some_at function.
The device to which the data is to be written. The type must support the SyncRandomAccessWriteDevice concept.
The offset at which the data will be written.
The basic_streambuf object from
which data will be written.
The function object to be called to determine whether the write operation is complete. The signature of the function object must be:
std::size_t completion_condition( // Result of latest write_some_at operation. const boost::system::error_code& error, // Number of bytes transferred so far. std::size_t bytes_transferred );
A return value of 0 indicates that the write operation is complete. A non-zero return value indicates the maximum number of bytes to be written on the next call to the device's write_some_at function.
Set to indicate what error occurred, if any.
The number of bytes written. If an error occurs, returns the total number of bytes successfully transferred prior to the error.
Context object that represents the currently executing coroutine.
typedef basic_yield_context< unspecified > yield_context;
|
Name |
Description |
|---|---|
|
The coroutine callee type, used by the implementation. |
|
|
The coroutine caller type, used by the implementation. |
|
Name |
Description |
|---|---|
|
Construct a yield context to represent the specified coroutine. |
|
|
Return a yield context that sets the specified error_code. |
The basic_yield_context class is used
to represent the currently executing stackful coroutine. A basic_yield_context may be passed
as a handler to an asynchronous operation. For example:
template <typename Handler> void my_coroutine(basic_yield_context<Handler> yield) { ... std::size_t n = my_socket.async_read_some(buffer, yield); ... }
The initiating function (async_read_some in the above example) suspends the current coroutine. The coroutine is resumed when the asynchronous operation completes, and the result of the operation is returned.
Header: boost/asio/spawn.hpp
Convenience header: None
template<> struct boost::system::is_error_code_enum< boost::asio::error::addrinfo_errors >
|
Name |
Description |
|---|---|
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
static const bool value = true;
template<> struct boost::system::is_error_code_enum< boost::asio::error::basic_errors >
|
Name |
Description |
|---|---|
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
static const bool value = true;
template<> struct boost::system::is_error_code_enum< boost::asio::error::misc_errors >
|
Name |
Description |
|---|---|
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
static const bool value = true;
template<> struct boost::system::is_error_code_enum< boost::asio::error::netdb_errors >
|
Name |
Description |
|---|---|
Header: boost/asio/error.hpp
Convenience header: boost/asio.hpp
static const bool value = true;
template<> struct boost::system::is_error_code_enum< boost::asio::error::ssl_errors >
|
Name |
Description |
|---|---|
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
static const bool value = true;
template<> struct boost::system::is_error_code_enum< boost::asio::ssl::error::stream_errors >
|
Name |
Description |
|---|---|
Header: boost/asio/ssl/error.hpp
Convenience header: boost/asio/ssl.hpp
static const bool value = true;