|
connect_pair function (which will
fail with an operation_not_supported error).
ip::basic_resolver.
experimental::as_single completion token adapter.
The as_single completion token adapter can be used to specify
that the completion handler arguments should be combined into a single
argument. For completion signatures with a single parameter, the argument
is passed through as-is. For signatures with two or more parameters, the
arguments are combined into a tuple. The as_single adapter
may be used in conjunction with use_awaitable and structured
bindings as follows:auto [e, n] = co_await socket.async_read_some(
asio::buffer(data), as_single(use_awaitable));
using default_token = as_single_t<use_awaitable_t<>>;
using tcp_socket = default_token::as_default_on_t<tcp::socket>;
// ...
awaitable<void> do_read(tcp_socket socket)
{
// ...
auto [e, n] = co_await socket.async_read_some(asio::buffer(data));
// ...
}
MSG_NOSIGNAL on more platforms by using
_POSIX_VERSION to detect whether it is supported.
executor concept to test for a const-qualified
execute().
any_executor support for builds without RTTI support.
thread_pool unit test to work without RTTI support.
asio::query.
push/pop_options.hpp includes.
select
reactor is used on Windows.
any_executor comparisons
and conversion.
strand<> adaptation of Networking TS executors
when targeting older C++ versions or less conformant compilers.
basic_socket_acceptor move constructor as noexcept.
gcc 10's coroutine
support.
windows::overlapped_ptr.
execution::receiver_of
concept.
execution::executor,
execution::operation_state,execution::sender,
execution::receiver, execution::receiver_of,
and execution::scheduler concepts and the corresponding traits.
These now test first for well-formed CPO expressions (or, in the case of
senders, a specialised sender_traits template) and, if not
valid, short-circuit the remainder of the evaluation. This helps prevent
recursive template instantiations that can occur in some contexts.
strand template's constructor, to
prevent template instantiation recursion.
execution::any_executor template's
converting constructors, as per the specification.
execution::sender_traits specialisation and
connect() member function to the thread_pool
executor, as per the specification.
execution::blocking_t::always_t::is_preferable to
be false as per the specification.
shape_type and index_type to thread_pool
executors, as per the specification.
execution::is_executor)
work with void.
async_compose support for standard executors.
any_io_executor in asio/ts/netfwd.hpp.
use_future compatibility with older compilers.
gcc.
clang-cl on Windows.
io_context executors, thread_pool executors,
system_executor, and strand<>.
io_context::executor_type, thread_pool::executor_type,
system_executor, and strand executors now
meet the requirements for the proposed standard executors. These
classes also continue to meet the existing requirements for the Networking
TS model of executors.
dispatch, post, defer, get_associated_executor,
bind_executor, make_work_guard, spawn,
co_spawn, async_compose, use_future,
etc., can interoperate with both new proposed standard executors,
and with existing Networking TS executors. The implementation determines
at compile time which model a particular executor meets; the proposed
standard executor model is used in preference if both are detected.
any_io_executor type alias has been introduced as
the new default runtime-polymorphic executor for all I/O objects.
This type alias points to the execution::any_executor<>
template with a set of supportable properties specified for use with
I/O. This change may break existing code that directly uses the old
polymorphic wrapper, executor. If required for backward
compatibility, ASIO_USE_TS_EXECUTOR_AS_DEFAULT can be
defined, which changes the any_io_executor type alias
to instead point to the executor polymorphic wrapper.
ASIO_NO_TS_EXECUTORS.
basic_waitable_timer.
This enables move construction and assignment between different timer types,
provided the executor types are convertible. For example:basic_waitable_timer<
clock_type,
traits_type,
io_context::executor_type
> timer1(my_io_context);
basic_waitable_timer<
clock_type,
traits_type,
any_io_executor // polymorphic wrapper
> timer2(std::move(timer1));
gcc 10.
co_spawn that launch an awaitable. This
change allows us to write:co_spawn(executor,
echo(std::move(socket)),
detached);
co_spawn(executor,
[socket = std::move(socket)]() mutable
{
return echo(std::move(socket));
},
detached);
use_awaitable_t's default
executor adapter, to enable conversion between executor types.
detached_t as a default completion
token, by adding members as_default_on() and as_default_on_t<>.
ssl::stream<>.
ssl::stream<> write operations to linearise
gather-write buffer sequences.
asio_handler_invoke
hook. This hook was deprecated with the introduction of the Networking
TS trait associated_executor and function get_associated_executor().
Compiling an application with ASIO_NO_DEPRECATED will now
trigger a compile error if any handler implements the asio_handler_invoke
hook.
asio_handler_allocate
and asio_handle_deallocate hooks. These hooks were deprecated
with the introduction of the Networking TS trait associated_allocator
and function get_associated_allocator(). Compiling an application
with ASIO_NO_DEPRECATED will now trigger a compile error if
any handler implements the asio_handler_allocate or asio_handler_deallocate
hooks.
recv rather
than recvmsg, send rather than sendmsg,
read rather than readv, and write
rather than writev.
executor.
errno and error codes when on an
error path.
io_context::exeutor_type) is detected.
ASIO_HANDLER_LOCATION((file_name,
line, function_name)) macro may be used to inform the handler tracking
mechanism of a source location. This macro declares an object that is placed
on the stack. Then, when an asynchronous operation is launched with location
information, it outputs lines using the <action>
n^m, prior to the n*m line that signifies
the beginning of the asynchronous operation. For example:
@asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5 @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330) @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62) @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51) @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5 @asio|1589423304.861980|<7|
std::source_location or std::experimental::source_location
are available, the use_awaitable_t token (when default-constructed
or used as a default completion token) will also cause handler tracking
to output a source location for each newly created asynchronous operation.
A use_awaitable_t object may also be explicitly constructed
with location information.
handlerviz.pl
tool.
handlerlive.pl tool, which processes handler
tracking output to produce a list of "live" handlers. Live handlers
are those that are associated with pending asynchronous operations, as
well as handlers that are currently executing. For example:
cat output.txt | perl handlerlive.plor:
perl handerlive.pl < output.txtor:
perl handlerlive.pl output.txt
handlertree.pl tool, which filters handler
tracking output to include only those events in the tree that produced
the nominated handlers. For example, to filter the output to include only
the events associated with handlers 123, 456,
and their predecessors:
cat output.txt | perl handlertree.pl 123 456or:
perl handlertree.pl 123 456 < output.txt
cat output.txt | \ perl handlertree.pl `perl handlerlive.pl output.txt` | \ perl handlerviz.pl | \ dot -Tsvg > output.svg
async_compose to work with copyable handlers when passed
by lvalue.
co_spawn.
Executor base class from the executor_binder
implementation.
noexcept.
ssl::host_name_verification class, which is a drop-in
replacement for ssl::rfc2818_verification. The ssl::rfc2818_verification
class has been marked as deprecated. As a consequence of this change, SSL
support now depends on functions that were introduced in OpenSSL 1.0.2.
ssl::context constructor to take ownership of a native
handle.
gcc to use
__cplusplus macro.
strand<> converting constructors and assignment
operators.
async_read
overloads.
ssl::context class to propagate non-EOF errors
from the add_certificate_authority function.
thread_pool destructor hang that
occurred when the pool had an associated I/O object.
select reactor to recreate the "self
pipe trick" sockets on error. This addresses an issue on some versions
of Windows, where these sockets are discconected after a system sleep.
priority_scheduler example to demonstrate calls
to shutdown() and destroy().
use_awaitable_t::as_default_on
function.
boost::placeholders
namespace.
async_compose implementation
due to incorrect overload selection.
async_initiate helper function to automatically
deduce its return type. This is enabled for C++11 or later.
return_type.
async_initiate.
completion_signature<T>: Checks if T
is a signature of the form R(Args...).
completion_handler_for<T, Signature>: Checks if
T is usable as a completion handler with the specified
signature.
completion_token_for<T, Signature>: Checks if
T is a completion token that can be used with async_initiate
and the specified signature.
(BOOST_)ASIO_COMPLETION_SIGNATURE,
(BOOST_)ASIO_COMPLETION_HANDLER_FOR, and (BOOST_)ASIO_COMPLETION_TOKEN_FOR
are provided. These macros expand to typename when concepts
are unsupported.
rebind_executor to all I/O
object types, as a way to generically rebind them to use alternative I/O
executors. For example:
using my_socket_type = tcp::socket::rebind_executor<my_executor_type>::other;
executor_type
and member function get_executor(). Note that the presence
of executor_type and get_executor() should be
treated as optional, and consequently it may be preferable to access them
via the associated_executor trait and the get_associated_executor()
helper function.
default_completion_token trait, so that every I/O
executor type now has an associated default completion token type. This
trait may be used in asynchronous operation declarations as follows:
template <
typename IoObject,
typename CompletionToken =
typename default_completion_token<
typename IoObject::executor_type
>::type
>
auto async_xyz(
IoObject& io_object,
CompletionToken&& token =
typename default_completion_token<
typename IoObject::executor_type
>::type{}
);
void, meaning
no default completion token type is available for the given I/O executor.
default_completion_token trait for the use_awaitable
completion token, so that it may be used as shown in the following example:
auto socket = use_awaitable.as_default_on(tcp::socket(my_context)); // ... co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
socket object is transformed
from tcp::socket to have an I/O executor with the default
completion token set to use_awaitable. Alternatively, the
socket type may be computed directly:
using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>; tcp_socket socket(my_context); // ... co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
async_initiate to the Windows-specific I/O objects'
asynchronous operations.
basic_socket_acceptor<ip::tcp, my_executor_type>
basic_stream_socket<ip::tcp, my_executor_type>
Protocol copy and move operations
never throw.
Endpoint default constructor and move
operations never throw.
noexcept qualifier to protocol accessors.
noexcept qualifier to socket move constructors.
case fall-through
in the free function connect() implementation.
is_*_buffer_sequence detection traits for user-defined
sequence types.
CancelIoEx entry point.
get_option() member function to be
const.
shutdown function.
is_dynamic_buffer.
async_accept between sockets with different
executor types.
Executor template
parameter. This template parameter defaults to the asio::executor
type (the polymorphic executor wrapper) but can be used to specify
a user-defined executor type.
asio::io_context& now accept either an Executor
or a reference to a concrete ExecutionContext (such
as asio::io_context or asio::thread_pool).
io_context for constructing
another I/O object, as in:
asio::steady_timer my_timer(my_socket.get_executor().context());
asio::steady_timer my_timer(my_socket.get_executor());
io_context:asio::steady_timer my_timer(my_io_context);
get_io_context and get_io_service
member functions have now been removed.
async_result form with an initiate
static member function.
async_result template now supports a new form:
template <typename CompletionToken, typename Signature>
struct async_result
{
typedef /* ... */ return_type;
template <typename Initiation,
typename RawCompletionToken,
typename... Args>
static return_type initiate(
Initiation&& initiation,
RawCompletionToken&& token,
Args&&... args);
};
initiate member function must: (a) transform the
token into a completion handler object handler; (b)
cause the invocation of the function object initiation
as if by calling std::forward<Initiation>(initiation)(std::move(handler),
std::forward<Args>(args)...). Note that the invocation
of initiation may be deferred (e.g. lazily evaluated),
in which case initiation and args must
be decay-copied and moved as required.
async_initiate has also been
added as a wrapper for the invocation of async_result<>::initiate.
For backward compatibility, this function supports both the old and
new async_result forms.
async_initiate.
handler_type trait and single-argument
form of async_result have now been removed.
asio
namespace.
awaitable<>, co_spawn, this_coro,
detached, and redirect_error facilities
have been moved from the asio::experimental namespace
to namespace asio. As part of this change, the this_coro::token()
awaitable has been superseded by the asio::use_awaitable
completion token.
use_awaitable and redirect_error
completion tokens work only with asynchronous operations that use
the new form of async_result with member function initiate.
Furthermore, when using use_awaitable, please be aware
that the asynchronous operation is not initiated until co_await
is applied to the awaitable<>.
DynamicBuffer_v2 concept which is CopyConstructible.
DynamicBuffer_v2, which supports copy construction.
These new type requirements enable dynamic buffers to be used as
arguments to user-defined composed operations, where the same dynamic
buffer object is used repeatedly for multiple underlying operations.
For example:template <typename DynamicBuffer>
void echo_line(tcp::socket& sock, DynamicBuffer buf)
{
n = asio::read_until(sock, buf, '\n');
asio::write(sock, buf, asio::transfer_exactly(n));
}
DynamicBuffer type requirements have been
renamed to DynamicBuffer_v1. These requirements continue
to be compatible with the Networking TS.
is_dynamic_buffer_v1 and is_dynamic_buffer_v2
have been added to test for conformance to DynamicBuffer_v1
and DynamicBuffer_v2 respectively. The existing is_dynamic_buffer
trait has been retained and delegates to is_dynamic_buffer_v1
(unless ASIO_NO_DYNAMIC_BUFFER_V1 is explicitly defined,
in which case it delegates to is_dynamic_buffer_v2).
dynamic_string_buffer and dynamic_vector_buffer
classes conform to both DynamicBuffer_v1 and DynamicBuffer_v2
requirements.
ASIO_NO_DYNAMIC_BUFFER_V1 is defined, all support
for DynamicBuffer_v1 types and functions is #ifdef-ed
out. Support for using basic_streambuf with the read,
async_read, read_until, async_read_until,
write, and async_write functions is also
disabled as a consequence.
async_compose function that simplifies the implementation
of user-defined asynchronous operations.
make_strand function, which creates a strand
with a deduced Executor template argument.
local::basic_endpoint that takes a
string_view.
ip::address,
ip::address_v4, ip::address_v6, ip::basic_endpoint,
and executor_work_guard classes.
buffer_sequence_begin
and buffer_sequence_end functions.
ASIO_DISABLE_VISIBILITY configuration #define
that allows visibility pragmas to be disabled. (Note: If symbols are hidden,
extra care must be taken to ensure that Asio types are not passed across
shared library API boundaries.)
ASIO_STANDALONE
automatically if C++11 or later is detected.
ASIO_ENABLE_BOOST to explicitly
disable standalone mode when compiling with C++11 or later.
configure script now defaults to a standalone build
unless Boost is specified or detected.
error::message_size) occurs on a datagram-oriented
socket.
SO_REUSEPORT
when the reuse_address option is set.
unistd.h when targeting Haiku OS, to fix
feature detection.
network_v[46].hpp headers to the top-level convenience
header.
pthread_cond_timedwait.
EndpointSequence
iterator type rather than assume the presence of a const_iterator
typedef.
buffer_sequence_begin and buffer_sequence_end
to prevent implicit conversion. This change addresses an issue where a
call to buffer_sequence_begin or buffer_sequence_end
could trigger an implicit conversion to const_buffer or mutable_buffer.
Whenever this implicit conversion occurred, the return value of buffer_sequence_begin
or buffer_sequence_end would point to a temporary object.
eof error on SSL shutdown as it actually indicates
success.
SSL_ERROR_SYSCALL
result without an associated error.
<atomic> when targeting apple/clang/libc++
with recent Xcode versions, even for C++03. This fixes a warning about
the deprecation of OSMemoryBarrier.
decltype support for
that compiler.
_WIN32_WINNT to 0x0601
(Windows 7).
dispatch documentation to note that it may call the
supplied function object in the current thread.
post and defer documentation to clarify
the the distinction between them.
std::future availability
with libstdc++.
read_until.
std::experimental::string_view and std::string_view
with newer clang/libc++.
std::invoke_result.
decltype
is available.
size(), max_size() or
empty() on default-constructed resolver results.
std::string_view detection issue when using clang-cl.
io_context::executor_type::dispatch.
basic_socket_acceptor::get_option.
experimental::detached completion token.
experimental::redirect_error completion token.
experimental::co_spawn facility for integration
with the coroutines technical specification.
asio::steady_timer rather than asio::deadline_timer.
asio::dynamic_buffer rather than asio::streambuf.
asio::io_context::run_for() function for
blocking clients.
(BOOST_)ASIO_NO_DEPRECATED
is defined.
(BOOST_)ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM
to enable the old Boost.Date_Time interface in basic_socket_streambuf
and basic_socket_iostream.
is_dynamic_buffer
trait.
async_result incompatibility with deprecated handler_type.
basic_resolver_results::value_type typedef.
SSL_OP_NO_COMPRESSION
is defined.
add_certificate_authority to process multiple certificates
in a bundle.
std::invoke_result
rather than std::result_of.
std::string_view for C++17 or later, and std::experimental::string_view
for C++14. Define the preprocessor macro (BOOST_)ASIO_DISABLE_STD_STRING_VIEW
to force the use of std::experimental::string_view (assuming it is available)
when compiling in C++17 mode.
DynamicBuffer template arguments are decayed before
using in enable_if tests.
basic_yield_context to work with completion signatures
containing reference parameters.
spawn() correctly
store decayed copies of their function and handler arguments.
basic_socket<Protocol,
SocketService> we now have simply basic_socket<Protocol>.
The old interface can be enabled by defining the (BOOST_)ASIO_ENABLE_OLD_SERVICES
macro.
io_context
basis.
ssl::stream<>
constructor argument.
Executor type requirements and classes to support
an executor framework, including the execution_context
base class, the executor_work class for tracking outstanding
work, and the executor polymorphic wrapper. Free functions
dispatch(), post() and defer()
have been added and are used to submit function objects to executors.
wrap() is used to associate
an executor with a handler or other object. The handler hooks for
allocation, invocation and continuation have been deprecated.
system_executor class has been added as a default
executor.
io_service class is now derived from execution_context
and implements the executor type requirements in its nested executor_type
class. The member functions dispatch(), post(),
defer() and wrap() have been deprecated.
The io_service::work class has been deprecated.
io_service member function reset()
has been renamed to restart(). The old name is retained
for backward compatibility but has been deprecated.
make_service<>() function is now used to add
a new service to an execution context such as an io_service.
The add_service() function has been deprecated.
strand<> template has been added to allow
strand functionality to be used with generic executor types.
io_service via a context() member
function. The get_io_service() member function is deprecated.
io_service::post(),
io_service::dispatch(), io_service::strand::post()
and io_service::strand::dispatch() functions still require
copyable handlers.
expiry() member function for obtaining the expiry
time. The accessors expires_at() and expires_after()
have been deprecated, though those names are retained for the mutating
members.
std::packaged_task class template is now supported
as a completion handler. The initiating operation automatically returns
the future associated with the task. The package() function
has been added as a convenient factory for packaged tasks.
wait()
and async_wait() operations that may be used to wait
for readiness. The null_buffers type has been deprecated.
address_cast<>(),
make_address(), make_address_v4() and
make_address_v6() free functions. The from_string(),
to_v4(), to_v6() and v4_mapped()
member functions have been deprecated.
ip::address now represents an
invalid address value that is neither IPv4 nor IPv6.
buffer() overloads that generate mutable buffers
for non-const string objects.
asio::streambuf class.
This support includes:
dynamic_string_buffer and dynamic_vector_buffer
adapter classes that meet the DynamicBufferSequence
type requirements.
dynamic_buffer() factory functions for creating
a dynamic buffer adapter for a vector or string.
read(), async_read(),
write() and async_write(), read_until()
and async_read_until() free functions that directly
support dynamic buffer sequences.
address_iterator_v4 for iterating across IPv4
addresses
address_iterator_v6 for iterating across IPv6
addresses
address_range_v4 to represent a range of IPv4
addresses
address_range_v6 to represent a range of IPv6
addresses
network_v4 for manipulating IPv4 CIDR addresses,
e.g. 1.2.3.0/24
network_v6 for manipulating IPv6 CIDR addresses,
e.g. ffe0:/120
<asio/ts/*.hpp>
that correspond to the headers in the proposal.
thread_pool class.
spawn() to be executor-aware.
spawn() overload that takes only a function object.
spawn() and yield_context to permit nested
calls to the completion handler.
std::endl to ensure output is
flushed.
ssl::stream<> bug that may result in spurious
'short read' errors.
ssl::stream<>
constructor argument.
yield_context
object with asynchronous operations.
ConnectEx function are
mapped to their portable equivalents.
join_group failures
as non-fatal.
kqueue reactor so that it works on FreeBSD.
kqueue reactor which resulted
in spinning when using serial ports on Mac OS.
kqueue reactor support for read-only file descriptors.
/dev/poll reactor.
WSASocketW, as WSASocketA
has been deprecated.
use_future and spawn()
are not made available when including the asio.hpp convenience
header.
asio::strand as deprecated. Use asio::io_service::strand
instead.
kqueue backend that was introduced
in Asio 1.10.2.
gcc
on AIX.
gcc problem to do with anonymous enums.
HANDLE backend change to ignore ERROR_MORE_DATA.
Instead, the error will be propagated as with any other (i.e. in an error_code
or thrown as a system_error), and the number of bytes transferred
will be returned. For code that needs to handle partial messages, the
error_code overload should be used.
signal_set implementation's
signal number check.
SO_UPDATE_CONNECT_CONTEXT
is defined.
VerifyVersionInfo
rather than GetVersionEx, as GetVersionEx has
been deprecated.
asio::spawn() to work correctly with new Boost.Coroutine
interface.
asio::spawn() coroutines are correctly
unwound when cleaned up by the io_service destructor.
io_service::wrap()
and strand::wrap().
ConnectEx,
if available, for connection-oriented IP sockets.
io_service backend for non-Windows (and non-IOCP
Windows) platforms to use a single condition variable per io_service
instance. This addresses a potential race condition when run_one()
is used from multiple threads.
boost::chrono
and std::chrono clocks.
EV_CLEAR handling in the kqueue backend,
to address other cases where the close() system call may hang
on Mac OS X.
resolver_query_base::flags::operator~.
select reactor more efficient on Windows for large
numbers of sockets.
gcc.
GetQueuedCompletionStatus timeout workaround
on recent versions of Windows.
FormatMessageW
rather than FormatMessageA, as the Windows store does not
permit the latter.
io_service, strand,
buffers, composed operations, timers, etc., should all work as normal.
cancel() function is not supported for sockets.
Asynchronous operations may only be cancelled by closing the socket.
null_buffers are not supported.
tcp::no_delay and socket_base::keep_alive
options are supported.
ASIO_STANDALONE on your compiler command
line or as part of the project options. This standalone configuration has
been tested for the following platforms and compilers:
-std=c++11)
-std=c++11 -stdlib=libc++)
async_connect were not correctly propagated through to
the completion handler.
io_service. When the
bug occurs, the result of an asynchronous operation (error and bytes tranferred)
is incorrectly discarded and zero values used instead. For TCP sockets
this results in spurious end-of-file notifications.
async_wait on a signal that is already raised.
async_write_at
operations.
HANDLE backend to treat ERROR_MORE_DATA
as a non-fatal error when returned by GetOverlappedResult
for a synchronous read.
generic as a keyword. Added
a workaround that renames the namespace to cpp_generic when
those language extensions are in effect.
async_result
support in 1.10.0. In particular, the buffered stream templates have been
updated so that they adhere to current handler patterns.
use_future support for Microsoft Visual Studio 2012.
std::min in the Windows IOCP backend to avoid
a dependency on the <algorithm> header.
SSL_CTX_clear_options
function.
handler_type and async_result,
that allow the customisation of the return type of an initiating function.
asio::spawn() function, a high-level wrapper for
running stackful coroutines, based on the Boost.Coroutine library. The
spawn() function enables programs to implement asynchronous
logic in a synchronous manner. For example: size_t n = my_socket.async_read_some(my_buffer,
yield);. For further information, see Stackful
Coroutines.
asio::use_future special value, which provides first-class
support for returning a C++11 std::future from an asynchronous
operation's initiating function. For example: future<size_t>
= my_socket.async_read_some(my_buffer, asio::use_future);. For further
information, see C++ 2011
Support - Futures.
asio_handler_is_continuation.
Asynchronous operations may represent a continuation of the asynchronous
control flow associated with the current executing handler. The asio_handler_is_continuation
hook can be customised to return true if this is the case,
and Asio's implementation can use this knowledge to optimise scheduling
of the new handler. To cover common cases, Asio customises the hook for
strands, spawn() and composed asynchronous operations.
generic::datagram_protocol,
generic::raw_protocol, generic::seq_packet_protocol
and generic::stream_protocol, which implement the Protocol
type requirements, but allow the user to specify the address family (e.g.
AF_INET) and protocol type (e.g. IPPROTO_TCP)
at runtime. For further information, see Support
for Other Protocols.
ip::tcp::socket
can be converted into a generic::stream_protocol::socket via
move construction. For further information, see Support
for Other Protocols.
basic_socket_acceptor<>'s accept()
and async_accept() functions to allow a new connection to
be accepted directly into a socket of a more generic type. For example,
an ip::tcp::acceptor can be used to accept into a generic::stream_protocol::socket
object. For further information, see Support
for Other Protocols.
ASIO_STANDALONE
on your compiler command line or as part of the project options. This standalone
configuration has currently been tested for the following platforms and
compilers:
-std=c++11)
-std=c++11 -stdlib=libc++)
ssl::stream<>
class's handshake() and async_handshake()
functions have been added. These accept a ConstBufferSequence
to be used as initial input to the ssl engine for the handshake procedure.
ssl::context
objects.
set_verify_depth() function to the ssl::context
and ssl::stream<> classes.
add_certificate_authority(),
use_certificate(), use_certificate_chain(),
use_private_key(), use_rsa_private_key()
and use_tmp_dh(), have been added to the ssl::context
class.
ssl::context to automatically disable SSL compression
by default. To enable, use the new ssl::context::clear_options()
function, as in my_context.clear_options(ssl::context::no_compression).
signal_set implementation.
#warning directive.
epoll implementation.
error_code with an invalid (i.e. NULL) error_category.
basic_waitable_timer's underlying implementation so
that it can handle any time_point value without overflowing
the intermediate duration objects.
run() and poll() on the same io_service
object.
ssl::rfc2818_verification class.
asio/detail/winsock_init.hpp for details.
basic_socket::get_option's
documentation.
long rather than int for SSL_CTX
options, to match OpenSSL.
_snwprintf to address a compile error due to
the changed swprintf signature in recent versions of MinGW.
io_service threads due to running out of work.
accept
as non-fatal.
ip::tcp::iostream and C++11.
#include <cctype>, needed for some versions
of MinGW.
gcc's atomic builtins on ARM CPUs, when
available.
io_service has been destroyed.
epoll_create1()
function but always fail with ENOSYS.
buffered_write_stream.
epoll_reactor backend to do lazy registration
for EPOLLOUT events.
epoll_reactor handling of out-of-band data, which
was broken by an incomplete fix in the last release.
OPENSSL_NO_ENGINE
feature test #define.
windows::object_handle so that it works with Windows
compilers that support C++11 move semantics (such as g++).
g++ 4.7 when compiling in C++11 mode.
signal_set handlers were not being delivered
when the io_service was constructed with a concurrency_hint
of 1.
basic_waitable_timer based around
the C++11 clock type requirements. It may be used with the clocks from
the C++11 <chrono> library facility or, if those are
not available, Boost.Chrono. The typedefs high_resolution_timer,
steady_timer and system_timer may be used to
create timer objects for the standard clock types.
windows::object_handle class for performing waits
on Windows kernel objects. Thanks go to Boris Schaeling for contributing
substantially to the development of this feature.
connect() can return EAGAIN in certain circumstances.
Remapped this to another error so that it doesn't look like a non-blocking
operation.
buffered_write_stream.
io_service
is repeatedly run without anything to do.
concurrency_hint is 1) to eliminate a lock/unlock
pair.
epoll_reactor speculative operations to
be performed without holding the lock.
epoll_reactor's
I/O operation immediately before the corresponding handler is called.
This also improves scalability across CPUs when multiple threads
are running the io_service.
boost::array or std::array)
of exactly two buffers.
async_read_until.
signal()
function from the global namespace.
deadline_timer implementation so that it does
not read the clock unless the timer heap is non-empty.
null_buffers operations
so that they obey the user's non-blocking setting.
fd_set at runtime when
using Windows.
epoll_reactor initialisation.
(BOOST_)ASIO_STRAND_IMPLEMENTATIONS
to the desired number.
(BOOST_)ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION
flag which switches the allocation of strand implementations to use a round-robin
approach rather than hashing.
strand.post()
is used.
-std=c++0x
mode on g++ 4.5 or higher.
signal()
or sigaction().
errno is preserved across the implementation's
signal handler.
io_service
destructor).
OPENSSL_NO_SSL2
is defined.
tick_count_timer example by making
the duration type signed. Previously, a wait on an already-passed deadline
would not return for a very long time.
(BOOST_)ASIO_ENABLE_OLD_SSL.
asio::buffer() overloads for std::array,
when available. The support is automatically enabled when compiling in
-std=c++0x mode on g++ 4.3 or higher, or when using
MSVC 10. The support may be explicitly enabled by defining (BOOST_)ASIO_HAS_STD_ARRAY,
or disabled by defining (BOOST_)ASIO_DISABLE_STD_ARRAY.
array,
shared_ptr, weak_ptr and atomic
when they are available, rather than the Boost equivalents.
std::error_code and std::system_error
is no longer enabled by default for g++ 4.5, as that compiler's standard
library does not implement std::system_error::what() correctly.
fork() system call. Programs that use
fork() must call io_service.notify_fork() at
the appropriate times. Two new examples have been added showing how to
use this feature.
close()
system call. In particular, assume that most operating systems won't have
close() fail with EWOULDBLOCK, but if it does
then set the blocking mode and restart the call. If any other error occurs,
assume the descriptor is closed.
EV_ONESHOT seems to cause problems on some
versions of Mac OS X, with the io_service destructor getting
stuck inside the close() system call. Changed the kqueue backend
to use EV_CLEAR instead.
what() messages.
shutdown_service() member functions to be private.
signal_set_service::cancel().
SignalHandler example.
signal_set_service.hpp
so that constants like NSIG may be used.
signal_set_service implementation so that it doesn't
assume that SIGRTMAX is a compile-time constant.
signal_set.
Programs may add one or more signals to the set, and then perform an async_wait()
operation. The specified handler will be called when one of the signals
occurs. The same signal number may registered with multiple signal_set
objects, however the signal number must be used only with Asio.
(BOOST_)ASIO_ENABLE_HANDLER_TRACKING, Asio writes debugging
output to the standard error stream. The output records asynchronous operations
and the relationships between their handlers. It may be post-processed
using the included handlerviz.pl tool to create a visual
representation of the handlers (requires GraphViz).
asio::streambuf where the consume()
function did not always update the internal buffer pointers correctly.
The problem may occur when the asio::streambuf is filled with
data using the standard C++ member functions such as sputn().
(Note: the problem does not manifest when the streambuf is populated by
the Asio free functions read(), async_read(),
read_until() or async_read_until().)
perform() function are not correctly
re-registered with kqueue.
std::error_code and std::system_error
is no longer enabled by default for MSVC10, as that compiler's standard
library does not implement std::system_error::what() correctly.
buffers_iterator<> and ip::basic_resolver_iterator
classes so that the value_type typedefs are non-const byte types.
ip::tcp::iostream.
A timeout is set by calling expires_at() or expires_from_now()
to establish a deadline. Any socket operations which occur past the deadline
will put the iostream into a bad state.
error() member function to socket iostreams, for
retrieving the error code from the most recent system call.
basic_deadline_timer::cancel_one() function. This
function lets you cancel a single waiting handler on a timer. Handlers
are cancelled in FIFO order.
transfer_exactly() completion condition. This
can be used to send or receive a specified number of bytes even if the
total size of the buffer (or buffer sequence) is larger.
connect() and async_connect().
These operations try each endpoint in a list until the socket is successfully
connected.
buffer_size() function so that it works for buffer
sequences in addition to individual buffers.
buffer_copy() function that can be used to copy
the raw bytes between individual buffers and buffer sequences.
read(), read_at(),
write() and write_at() that do not require a
completion condition.
static_assert
is also used to generate an informative error message. This checking may
be disabled by defining (BOOST_)ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS.
std::error_code and std::system_error,
when available. The support is automatically enabled when compiling in
-std=c++0x mode on g++ 4.5 or higher, or when using
MSVC 10. The support may be explicitly enabled by defining ASIO_HAS_STD_SYSTEM_ERROR,
or disabled by defining ASIO_DISABLE_STD_SYSTEM_ERROR. (Available
in non-Boost version of Asio only.)
is_loopback(), is_unspecified() and
is_multicast() functions consistently available across the
ip::address, ip::address_v4 and ip::address_v6
classes.
non_blocking() functions for managing the non-blocking
behaviour of a socket or descriptor. The io_control() commands
named non_blocking_io are now deprecated in favour of these
new functions.
native_non_blocking() functions for managing the
non-blocking mode of the underlying socket or descriptor. These functions
are 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 functions have no effect on the behaviour of
the synchronous operations of the socket or descriptor.
io_control() member function for socket acceptors.
native_type
typedefs in favour of native_handle_type, and the native()
member functions in favour of native_handle().
release() member function to posix descriptors. This
function releases ownership of the underlying native descriptor to the
caller.
SOCK_SEQPACKET).
io_service::stopped() function that can be used
to determine whether the io_service has stopped (i.e. a reset()
call is needed prior to any further calls to run(), run_one(),
poll() or poll_one()).
-std=c++0x
mode on g++ 4.5 or higher, or when using MSVC10.
ip::basic_endpoint<> objects (such
as ip::tcp::endpoint and ip::udp::endpoint).
assign() may have been dup()-ed,
and so require explicit deregistration from the reactor.
io_service().
The get_io_service() member functions should be used instead.
resolver_query and resolver_iterator
from the ip::tcp, ip::udp and ip::icmp
classes.
FIONBIO constant to int to suppress
a compiler warning on some platforms.
-Wshadow compiler option.
ip::address_v4::broadcast()
is used on 64-bit platforms.
timerfd
support) that prevents timely delivery of deadline_timer handlers,
after the program has been running for some time.
deadline_timer
may never fire if the io_service is running in a background
thread.
has_service<>
from compiling.
close()/closesocket() failures are correctly
propagated.
InitializeCriticalSectionAndSpinCount.
pselect() on HP-UX, if it is available.
deadline_timer objects
with expiry times set more than 5 minutes in the future may never expire.
0, as per the documentation.
const_buffers_1.
Protocol and id to avoid clashing with
Objective-C++ keywords.
vector reallocation performance issue that can occur
when there are many active deadline_timer objects.
io_control() implementation on 64-bit Mac
OS X and BSD platforms.
accept()
are incorrectly treated as successes.
asio/impl/src.cpp
in favour of asio/impl/src.hpp.
#includes, e.g. if the program uses boost::array but does
not explicitly include <boost/array.hpp>.)
deadline_timer implementation to improve performance.
asio::streambuf with async_read()
and async_read_until(). These read operations now use the
existing capacity of the streambuf when reading, rather than
limiting the read to 512 bytes.
asio/impl/src.cpp
in one source file in a program, then build the program with (BOOST_)ASIO_SEPARATE_COMPILATION
defined in the project/compiler settings. Alternatively, (BOOST_)ASIO_DYN_LINK
may be defined to build a separately-compiled Asio as part of a shared
library.
(BOOST_)ASIO_DISABLE_FENCED_BLOCK to permit
the disabling of memory fences around completion handlers, even if thread
support is enabled.
null_buffers variant of
async_send_to.
isdigit in getaddrinfo
emulation.
buffers_iterator.
null_buffers operations on Windows.
timerfd for dispatching timers on Linux, when
available.
ip::resolver_query_base::flags as per
the TR2 proposal. This type prevents implicit conversion from int
to flags, allowing the compiler to catch cases where users
incorrectly pass a numeric port number as the service name.
#define NOMINMAX for all Windows compilers. Users can
define (BOOST_)ASIO_NO_NOMINMAX to suppress this definition.
error::eof result to the completion handler.
io_control() member functions to always call
ioctl on the underlying descriptor when modifying blocking
mode.
InternetProtocol::resolver_query and InternetProtocol::resolver_iterator,
as neither typedef is part of the documented InternetProtocol
requirements. The corresponding typedefs in the ip::tcp,
ip::udp and ip::icmp classes have been deprecated.
select().
(BOOST_)ASIO_DISABLE_THREADS macro that allows Asio's
threading support to be independently disabled.
boost::addressof
to get the address of handler objects, rather than applying operator&
directly.
OVERLAPPED structure to be valid until both the initiating
function call has returned and the completion packet has been delivered.
boost_ prefix to the extern "C"
thread entry point function.
getaddrinfo emulation, only check the socket type (SOCK_STREAM
or SOCK_DGRAM) if a service name has been specified. This
should allow the emulation to work with raw sockets.
buffered*_stream<> templates to treat 0-byte
reads and writes as no-ops, to comply with the documented type requirements
for SyncReadStream, AsyncReadStream, SyncWriteStream
and AsyncWriteStream.
throw keyword to boost::throw_exception()
to allow Asio to be used when exception support is disabled. Note that
the SSL wrappers still require exception support.
HANDLE fails.
_GLIBCXX_DEBUG is defined.
(BOOST_)ASIO_HASH_MAP_BUCKETS
may be used to tweak the sizes used for the bucket arrays. (N.B. this feature
introduced a bug which was fixed in Asio 1.4.3 / Boost 1.40.)
io_control() so that it adheres
to the documented type requirements for IoControlCommand.
ReadFile
call fails with ERROR_MORE_DATA. This enables a hack where
a windows::stream_handle can be used with a message-oriented
named pipe.
(BOOST_)ASIO_DISABLE_SERIAL_PORT
is defined.
windows::overlapped_ptr::complete() are
correctly passed to the completion handler.
size_t CompletionCondition(error_code
ec, size_t total), where the return value indicates the maximum
number of bytes to be transferred on the next read or write operation.
(The old CompletionCondition signature is still supported for backwards
compatibility).
windows::overlapped_ptr class to allow arbitrary overlapped
I/O functions (such as TransmitFile) to be used with Asio.
eventfd descriptor is now
used (rather than a pipe) to interrupt a blocked select/epoll reactor.
lowest_layer().
io_service implementations now use lazy initialisation
to reduce the memory usage of an io_service object used only
as a message queue.
HANDLEs such as
named pipes (requires HANDLEs that work with I/O completion
ports).
HANDLEs such as files
(requires HANDLEs that work with I/O completion ports).
null_buffers type.
read_until() and async_read_until()
overloads that take a user-defined function object for locating message
boundaries.
(BOOST_)ASIO_ENABLE_TWO_LOCK_QUEUE)
that may provide better io_service scalability across many
processors.
First stable release of Asio.