ConnectExfunction are mapped to their portable equivalents (#10744).
BOOST_ASIO_DISABLE_CONNECTEXto allow use of
ConnectExto be explicitly disabled.
windows::object_handlewhen there are pending wait operations on destruction (#10624).
ssl::stream<>bug that may result in spurious 'short read' errors.
join_groupfailures as non-fatal.
std::endlto ensure output is flushed.
yield_contextobject with asynchronous operations.
yield_contextto allow reentrant calls to the completion handler from an initiating function.
kqueuereactor so that it works on FreeBSD (#10606).
kqueuereactor which resulted in spinning when using serial ports on Mac OS (#10496).
kqueuereactor support for read-only file descriptors (#10367).
/dev/pollreactor (#10350, #10572).
WSASocketAhas been deprecated (#10534).
spawn()are not made available when including the
asio.hppconvenience header (#10567).
asio::strandas deprecated. Use
kqueuebackend that was introduced in Asio 1.10.2.
gccproblem to do with anonymous enums (#10042).
HANDLEbackend change to ignore
ERROR_MORE_DATA. Instead, the error will be propagated as with any other (i.e. in an
error_codeor thrown as a
system_error), and the number of bytes transferred will be returned. For code that needs to handle partial messages, the
error_codeoverload should be used (#10034).
signal_setimplementation's signal number check (#9324).
SO_UPDATE_CONNECT_CONTEXTis defined (#10016).
GetVersionExhas been deprecated.
asio::spawn()to work correctly with new Boost.Coroutine interface (#9442, #9928).
asio::spawn()coroutines are correctly unwound when cleaned up by the
ConnectEx, if available, for connection-oriented IP sockets.
io_servicebackend for non-Windows (and non-IOCP Windows) platforms to use a single condition variable per
io_serviceinstance. This addresses a potential race condition when
run_one()is used from multiple threads.
std::chronoclocks (#9662, #9778).
EV_CLEARhandling in the kqueue backend, to address other cases where the
close()system call may hang on Mac OS X.
selectreactor more efficient on Windows for large numbers of sockets (#9528).
GetQueuedCompletionStatustimeout workaround on recent versions of Windows.
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_buffersare not supported.
socket_base::keep_aliveoptions are supported.
async_connectwere not correctly propagated through to the completion handler (#8795).
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 (#8933).
async_waiton a signal that is already raised (#8738).
HANDLEbackend to treat
ERROR_MORE_DATAas a non-fatal error when returned by
GetOverlappedResultfor a synchronous read (#8722).
genericas a keyword. Added a workaround that renames the namespace to
cpp_genericwhen those language extensions are in effect.
async_resultsupport in Boost 1.54. In particular, the buffered stream templates have been updated so that they adhere to current handler patterns (#9000, #9001).
use_futuresupport for Microsoft Visual Studio 2012.
std::minin the Windows IOCP backend to avoid a dependency on the
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_futurespecial value, which provides first-class support for returning a C++11
std::futurefrom 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_continuationhook can be customised to return
trueif 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::stream_protocol, which implement the
Protocoltype 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::socketcan be converted into a
generic::stream_protocol::socketvia move construction. For further information, see Support for Other Protocols.
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::acceptorcan be used to accept into a
generic::stream_protocol::socketobject. For further information, see Support for Other Protocols.
async_handshake()functions have been added. These accept a
ConstBufferSequenceto be used as initial input to the ssl engine for the handshake procedure.
set_verify_depth()function to the
use_tmp_dh(), have been added to the
ssl::contextto automatically disable SSL compression by default. To enable, use the new
ssl::context::clear_options()function, as in
error_codewith an invalid (i.e.
basic_waitable_timer's underlying implementation so that it can handle any
time_pointvalue without overflowing the intermediate duration objects.
poll()on the same
basic_socket::get_option's documentation (#7562).
intfor SSL_CTX options, to match OpenSSL (#7209).
_snwprintfto address a compile error due to the changed
swprintfsignature in recent versions of MinGW (#7373).
io_servicethreads due to running out of work (#7552).
noexceptqualifier for error categories (#7797).
acceptas non-fatal (#7488).
ip::tcp::iostreamand C++11 (#7162).
#include <cctype>, needed for some versions of MinGW.
gcc's atomic builtins on ARM CPUs, when available (#7140).
io_servicehas been destroyed.
epoll_create1()function but always fail with
epoll_reactorbackend to do lazy registration for
epoll_reactorhandling of out-of-band data, which was broken by an incomplete fix in the last release.
windows::object_handleso that it works with Windows compilers that support C++11 move semantics (such as
g++4.7 when compiling in C++11 mode (#6620).
signal_sethandlers were not being delivered when the
io_servicewas constructed with a
concurrency_hintof 1 (#6657).
basic_waitable_timerbased 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
system_timermay be used to create timer objects for the standard clock types.
windows::object_handleclass 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 (#6048).
io_serviceis repeatedly run without anything to do (#6321).
concurrency_hintis 1) to eliminate a lock/unlock pair.
epoll_reactorspeculative 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
std::array) of exactly two buffers.
signal()function from the global namespace (#5722).
deadline_timerimplementation so that it does not read the clock unless the timer heap is non-empty.
null_buffersoperations so that they obey the user's non-blocking setting (#5756).
fd_setat runtime when using Windows.
BOOST_ASIO_STRAND_IMPLEMENTATIONSto the desired number.
BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATIONflag which switches the allocation of strand implementations to use a round-robin approach rather than hashing.
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 be registered with multiple
signal_setobjects, however the signal number must be used only with Asio. Addresses #2879.
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.pltool to create a visual representation of the handlers (requires GraphViz).
ip::tcp::iostream. A timeout is set by calling
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.
async_connect(). These operations try each endpoint in a list until the socket is successfully connected, and are useful for creating TCP clients that work with both IPv4 and IPv6.
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.
write_at()that do not require a completion condition.
g++4.5 or later, and MSVC 10),
static_assertis also used to generate an informative error message. This checking may be disabled by defining
BOOST_ASIO_ENABLE_OLD_SSL. Addresses #3702, #3958.
boost/asio/ssl/impl/src.hppin one source file in your program.
is_multicast()functions consistently available across the
non_blocking()functions for managing the non-blocking behaviour of a socket or descriptor. The
non_blocking_ioare 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 (#3297).
release()member function to posix descriptors. This function releases ownership of the underlying native descriptor to the caller. Addresses #3900.
io_service::stopped()function that can be used to determine whether the
io_servicehas stopped (i.e. a
reset()call is needed prior to any further calls to
native_typetypedefs in favour of
native_handle_type, and the
native()member functions in favour of
fork()system call. Programs that use
io_service.notify_fork()at the appropriate times. Two new examples have been added showing how to use this feature. Addresses #3238, #4162.
close()system call. In particular, assume that most operating systems won't have
EWOULDBLOCK, but if it does then set the blocking mode and restart the call. If any other error occurs, assume the descriptor is closed. Addresses #3307.
std::array, when available.
atomicwhen they are available, rather than the Boost equivalents.
shutdown_service()member functions to be private.
ip::basic_endpoint<>objects (such as
assign()may have been
dup()-ed, and so require explicit deregistration from the reactor (#4971).
get_io_service()member functions should be used instead.
ip::basic_resolver_iteratorclasses so that the value_type typedefs are non-const byte types.
-Wshadowcompiler option (#3905).
FIONBIOconstant to int, to suppress a compiler warning on some platforms (#5128).
tick_count_timerexample by making the duration type signed. Previously, a wait on an already-passed deadline would not return for a very long time (#5418).
EV_ONESHOTseems to cause problems on some versions of Mac OS X, with the
io_servicedestructor getting stuck inside the
close()system call. Changed the kqueue backend to use
g++due to the use of anonymous enums (#4883).
EWOULDBLOCKare not correctly re-registered with kqueue.
asio::streambufto ensure that its internal pointers are updated correctly after the data has been modified using
ip::address_v4::broadcast()is used on 64-bit platforms.
deadline_timermay never fire if the
io_serviceis running in a background thread (#4568).
has_service<>from compiling (#4638).
closesocket()failures are correctly propagated (#4573).
pselect()on HP-UX, if it is available (#4578).
deadline_timerobjects with expiry times set more than 5 minutes in the future may never expire (#4745).
resolverbackend on BSD platforms so that an empty service name resolves to port number
0, as per the documentation (#4690).
idto avoid clashing with Objective-C++ keywords (#4191).
vectorreallocation performance issue that can occur when there are many active
io_control()implementation on 64-bit Mac OS X and BSD platforms (#4782).
accept()are incorrectly treated as successes (#4859).
<boost/asio/impl/src.cpp>in favour of
#includes, e.g. if the program uses
boost::arraybut does not explicitly include
deadline_timerimplementation to improve performance.
async_read_until(). These read operations now use the existing capacity of the
streambufwhen reading, rather than limiting the read to 512 bytes.
#include <boost/asio/impl/src.cpp>to one source file in a program, then build the program with
BOOST_ASIO_SEPARATE_COMPILATIONdefined in the project/compiler settings. Alternatively,
BOOST_ASIO_DYN_LINKmay be defined to build a separately-compiled Asio as part of a shared library.
BOOST_ASIO_DISABLE_FENCED_BLOCKto permit the disabling of memory fences around completion handlers, even if thread support is enabled.
unsigned charis used with
null_buffersoperations on Windows.
timerfdfor dispatching timers on Linux, when available.
ip::resolver_query_base::flagsas per the TR2 proposal. This type prevents implicit conversion from
flags, allowing the compiler to catch cases where users incorrectly pass a numeric port number as the service name.
#define NOMINMAXfor all Windows compilers. Users can define
BOOST_ASIO_NO_NOMINMAXto suppress this definition (#3901).
error::eofresult to the completion handler (#4023).
io_control()member functions to always call
ioctlon the underlying descriptor when modifying blocking mode (#3307).
InternetProtocol::resolver_iterator, as neither typedef is part of the documented
InternetProtocolrequirements. The corresponding typedefs in the
ip::icmpclasses have been deprecated.
BOOST_ASIO_DISABLE_THREADSmacro that allows Asio's threading support to be independently disabled.
boost::addressofto get the address of handler objects, rather than applying
OVERLAPPEDstructure 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 (#3809).
getaddrinfoemulation, only check the socket type (
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
boost::throw_exception()to allow Asio to be used when exception support is disabled. Note that the SSL wrappers still require exception support (#2754).
_GLIBCXX_DEBUGis defined (#3098).
BOOST_ASIO_HASH_MAP_BUCKETSmay 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 (#2820).
ReadFilecall fails with
ERROR_MORE_DATA. This enables a hack where a
windows::stream_handlecan be used with a message-oriented named pipe (#2936).
BOOST_ASIO_DISABLE_SERIAL_PORTis defined (#2917).
windows::overlapped_ptr::complete()are correctly passed to the completion handler (#2614).
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).
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).
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_servicescalability across many processors.
First release of Asio as part of Boost.