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.