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