![]() |
(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
.
#include
s, 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.
HANDLE
s
such as named pipes (requires HANDLE
s
that work with I/O completion ports).
HANDLE
s
such as files (requires HANDLE
s
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.