Repeated re-registration of kqueue event filters seems to behave as
though there is some kind of "leak" on MacOS, culminating in a suspended
close() system call and an unkillable process. To avoid this, we will
register a descriptor's kqueue event filters once only i.e. when the
descriptor is first created.
We must take care not to hold a shared_ptr to the coroutine across
its own suspension point, otherwise it will not be unwound by the
io_service destructor. Move-enabled C++11 compilers take care of this
automatically, but with C++03 we must explicitly reset the shared_ptr.
Fixes boost trac ticket #9731.
This change adds limited support for using Asio with the Windows
Runtime. It requires that the language extensions be enabled. Due to the
restricted facilities exposed by the Windows Runtime API, the port comes
with the following caveats:
* The core facilities such as the io_service, strand, buffers, composed
operations, timers, etc., should all work as normal.
* For sockets, only client-side TCP is supported.
* Explicit binding of a client-side TCP socket is not supported.
* The cancel() function is not supported for sockets. Asynchronous
operations may only be cancelled by closing the socket.
* Operations that use null_buffers are not supported.
* Only tcp::no_delay and socket_base::keep_alive options are supported.
* Resolvers do not support service names, only numbers. I.e. you must
use 80 rather than http.
* Most resolver query flags have no effect.
[SVN r85764]
To mitigate the risk of certain attacks, SSL compression is now disabled
by default. To enable, you can use the new ssl::context::clear_options()
function like so:
my_context.clear_options(asio::ssl::context::no_compression);
[SVN r84486]
Four new protocol classes have been added:
- asio::generic::datagram_protocol
- asio::generic::raw_protocol
- asio::generic::seq_packet_protocol
- asio::generic::stream_protocol
These classes 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.
A new endpoint class template, asio::generic::basic_endpoint, has been
added to support these new protocol classes. This endpoint can hold any
other endpoint type, provided its native representation fits into a
sockaddr_storage object.
When using C++11, it is now possible to perform move construction from a
socket (or acceptor) object to convert to the more generic protocol's
socket (or acceptor) type. If the protocol conversion is valid:
Protocol1 p1 = ...;
Protocol2 p2(p1);
then the corresponding socket conversion is allowed:
Protocol1::socket socket1(io_service);
...
Protocol2::socket socket2(std::move(socket1));
For example, one possible conversion is from a TCP socket to a generic
stream-oriented socket:
asio::ip::tcp::socket socket1(io_service);
...
asio::generic::stream_protocol::socket socket2(std::move(socket1));
The conversion is also available for move-assignment. Note that these
conversions are not limited to the newly added generic protocol classes.
User-defined protocols may take advantage of this feature by similarly
ensuring the conversion from Protocol1 to Protocol2 is valid, as above.
As a convenience, the socket acceptor's accept() and async_accept()
functions have been changed so that they can directly accept into a
different protocol's socket type, provided the protocol conversion is
valid. For example, the following is now possible:
asio::ip::tcp::acceptor acceptor(io_service);
...
asio::generic::stream_protocol::socket socket1(io_service);
acceptor.accept(socket1);
[SVN r84363]
Added new buffer-based interfaces:
add_certificate_authority, use_certificate, use_certificate_chain,
use_private_key, use_rsa_private_key, use_tmp_dh.
Thanks go to Nick Jones <nick dot fa dot jones at gmail dot com>, on
whose work this commit is based.
[SVN r84325]
Thanks go to Alvin Cheung <alvin dot cheung at alumni dot ust dot hk>
and Nick Jones <nick dot fa dot jones at gmail dot com>, on whose work
this is based.
[SVN r84320]
Add new overloads of the SSL stream's handshake() and async_handshake()
functions, that accepts a ConstBufferSequence to be used as initial
input to the ssl engine for the handshake procedure.
Thanks go to Nick Jones <nick dot fa dot jones at gmail dot com>, on
whose work this commit is partially based.
[SVN r84319]
Asynchronous operations may represent a continuation of the asynchronous
control flow associated with the current handler. Asio's implementation
can use this knowledge to optimise scheduling of the handler.
The asio_handler_is_continuation hook returns true to indicate whether a
completion handler represents a continuation of the current call
context. The default implementation of the hook returns false, and
applications may customise the hook when necessary. The hook has already
been customised within Asio to return true for the following cases:
- Handlers returned by strand.wrap(), when the corresponding
asynchronous operation is being initiated from within the strand.
- The internal handlers used to implement the asio::spawn() function's
stackful coroutines.
- When an intermediate handler of a composed operation (e.g.
asio::async_read(), asio::async_write(), asio::async_connect(),
ssl::stream<>, etc.) starts a new asynchronous operation due to the
composed operation not being complete.
To support this optimisation, a new running_in_this_thread() member
function has been added to the io_service::strand class. This function
returns true when called from within a strand.
[SVN r84314]
for returning a C++11 std::future from an asynchronous operation's
initiating function.
To use asio::use_future, pass it to an asynchronous operation instead of
a normal completion handler. For example:
std::future<std::size_t> length =
my_socket.async_read_some(my_buffer, asio::use_future);
Where a completion handler signature has the form:
void handler(error_code ec, result_type result);
the initiating function returns a std::future templated on result_type.
In the above example, this is std::size_t. If the asynchronous operation
fails, the error_code is converted into a system_error exception and
passed back to the caller through the future.
Where a completion handler signature has the form:
void handler(error_code ec);
the initiating function returns std::future<void>. As above, an error
is passed back in the future as a system_error exception.
[SVN r84313]
stackful coroutines. It is based on the Boost.Coroutine library.
Here is an example of its use:
asio::spawn(my_strand, do_echo);
// ...
void do_echo(asio::yield_context yield)
{
try
{
char data[128];
for (;;)
{
std::size_t length =
my_socket.async_read_some(
asio::buffer(data), yield);
asio::async_write(my_socket,
asio::buffer(data, length), yield);
}
}
catch (std::exception& e)
{
// ...
}
}
The first argument to asio::spawn() may be a strand, io_service or
completion handler. This argument determines the context in which the
coroutine is permitted to execute. For example, a server's per-client
object may consist of multiple coroutines; they should all run on the
same strand so that no explicit synchronisation is required.
The second argument is a function object with signature (**):
void coroutine(asio::yield_context yield);
that specifies the code to be run as part of the coroutine. The
parameter yield may be passed to an asynchronous operation in place of
the completion handler, as in:
std::size_t length =
my_socket.async_read_some(
asio::buffer(data), yield);
This starts the asynchronous operation and suspends the coroutine. The
coroutine will be resumed automatically when the asynchronous operation
completes.
Where a completion handler signature has the form:
void handler(error_code ec, result_type result);
the initiating function returns the result_type. In the async_read_some
example above, this is std::size_t. If the asynchronous operation fails,
the error_code is converted into a system_error exception and thrown.
Where a completion handler signature has the form:
void handler(error_code ec);
the initiating function returns void. As above, an error is passed back
to the coroutine as a system_error exception.
To collect the error_code from an operation, rather than have it throw
an exception, associate the output variable with the yield_context as
follows:
error_code ec;
std::size_t length =
my_socket.async_read_some(
asio::buffer(data), yield[ec]);
**Note: if asio::spawn() is used with a custom completion handler of
type Handler, the function object signature is actually:
void coroutine(asio::basic_yield_context<Handler> yield);
[SVN r84311]
incomplete and broke out-of-band handling. Fixed epoll_reactor::start_op so
that it is now exactly the same as the older, working version.
[SVN r78664]
BOOST_ASIO_STRAND_IMPLEMENTATIONS to the number.
Programs can now define BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION to
switch the allocation of strand implementations to use a round-robin approach
rather than hashing.
Fix potential strand starvation issue that can occur when strand.post() is used.
[SVN r74955]
* Split the task_io_service's run and poll code.
* Use thread-local operation queues in single-threaded use cases (i.e. concurrency_hint is 1) to eliminate a lock/unlock pair.
* Only fence block exit when a handler is being run directly out of the io_service.
* Prefer x86 mfence-based fenced block when available.
* Use a plain ol' long for the atomic_count when all thread support is disabled.
* Allow some epoll_reactor speculative operations to be performed without holding the lock.
* Improve locality of reference by performing an 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.
* Pass same error_code variable through to each operation's complete() function.
* Optimise creation of and access to the io_service implementation.
[SVN r74826]
* Duration type should be signed in tick_count_timer example.
* Regenerate documentation.
* Make definition of BOOST_ASIO_MOVE_ARG and BOOST_ASIO_MOVE_CAST separate to
the definition of BOOST_ASIO_HAS_MOVE, to allow the latter to be user-defined.
[SVN r72404]
* On Windows, ensure the count of outstanding work is decremented for
abandoned operations (i.e. operations that are being cleaned up within
the io_service destructor).
* Fix basic_socket_streambuf compile error when using MSVC 10's std::array.
* Preserve the value of errno across the signal handler.
* Fix unused return value warning.
* Fix various minor documentation errors.
[SVN r70751]
* Improve backward compatibility of the new SSL implementation.
* Add wrapper for SSL_CTX_set_default_verify_paths().
* Document which OpenSSL functions the ssl::context member functions use.
* Add SSL certificate verification callbacks, and add a new
ssl::rfc2818_verification function object for simple peer certificate
verification based on the host name.
* Use std::atomic<> when available.
* Prefer to use std::array when it is available.
* Use std::shared_ptr and std::weak_ptr when available.
* Use a lightweight scoped smart pointer.
* Fix some shadow variable warnings with g++ 4.6.
[SVN r70384]
* Added support for C++0x move construction and assignment to sockets, serial
ports, POSIX descriptors and Windows handles.
* Regenerate documentation.
[SVN r70092]
io_service.notify_fork() at the appropriate times. Two new examples have been
added showing how to use this feature. Refs #3238, #4162.
* Clean up the handling of errors reported by the close() system call. In
particular, assume that most operating systems won't have close() fail with
EWOULDBLOCK, but if it does then set blocking mode and restart the call. If
any other error occurs we assume the descriptor is closed. Refs #3307.
* 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. Use
EV_CLEAR instead. Refs #5021.
* Include function name in exception what() messages.
* Fix insufficient initialisers warning with MinGW.
* Make the shutdown_service() member functions private.
* Add archetypes for testing socket option functions.
* Add missing lock in signal_set_service::cancel().
* Fix copy/paste error in SignalHandler example.
* The signal header needs to be included in signal_set_service.hpp so that we
can use constants like NSIG and SIGRTMAX.
* Don't use Boost.Thread's convenience header. Use the header file that is
specifically for the boost::thread class instead.
[SVN r69467]
* Added support for signal handling, using a new class called
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.
* Added handler tracking, a new debugging aid. When enabled by defining
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).
* Fixed a bug in 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().)
* Fixed a bug on kqueue-based platforms, where reactor read operations
that return false from their perform() function are not correctly
re-registered with kqueue.
* Modified the buffers_iterator<> and ip::basic_resolver_iterator
classes so that the value_type typedefs are non-const byte types.
[SVN r69198]
* Added support for timeouts on socket iostreams, such as
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.
* Added a new error() member function to socket iostreams, for
retrieving the error code from the most recent system call.
* Added a new basic_deadline_timer::cancel_one() function. This function
lets you cancel a single waiting handler on a timer. Handlers are
cancelled in FIFO order.
* Added a new 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.
* Added new free functions connect() and async_connect(). These
operations try each endpoint in a list until the socket is
successfully connected.
* Extended the buffer_size() function so that it works for buffer
sequences in addition to individual buffers.
* Added a new buffer_copy() function that can be used to copy the raw
bytes between individual buffers and buffer sequences.
* Added new non-throwing overloads of read(), read_at(), write() and
write_at() that do not require a completion condition.
* Added friendlier compiler errors for when a completion handler does
not meet the necessary type requirements. When C++0x is available
(currently supported for g++ 4.5 or later, and MSVC 10), static_assert
is also used to generate an informative error message. Checking may be
disabled by defining BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS.
* Made the is_loopback(), is_unspecified() and is_multicast() functions
consistently available across the ip::address, ip::address_v4 and
ip::address_v6 classes. Refs #3939.
* Added new 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.
* Added new 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. Refs #3307.
* Added the io_control() member function for socket acceptors.
Refs #3297.
* For consistency with the C++0x standard library, deprecated the
native_type typedefs in favour of native_handle_type, and the native()
member functions in favour of native_handle().
* Added a release() member function to posix descriptors. This function
releases ownership of the underlying native descriptor to the caller.
Refs #3900.
* Added support for sequenced packet sockets (SOCK_SEQPACKET).
* Added a new 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()).
* Reduced the copying of handler function objects.
* Added support for C++0x move construction to further reduce copying of
handler objects. Move support is enabled when compiling in -std=c++0x
mode on g++ 4.5 or higher, or when using MSVC10.
* Removed the dependency on OS-provided macros for the well-known IPv4
and IPv6 addresses. This should eliminate the annoying "missing braces
around initializer" warnings. Refs #3741.
* Reduced the size of ip::basic_endpoint<> objects (such as
ip::tcp::endpoint and ip::udp::endpoint).
* Changed the reactor backends to assume that any descriptors or sockets
added using assign() may have been dup()-ed, and so require explicit
deregistration from the reactor. Refs #4971.
* Changed the SSL error category to return error strings from the
OpenSSL library.
* Changed the separate compilation support such that, to use Asio's SSL
capabilities, you should also include 'asio/ssl/impl/src.hpp in one
source file in your program.
* Removed the deprecated member functions named io_service(). The
get_io_service() member functions should be used instead.
* Removed the deprecated typedefs resolver_query and resolver_iterator
from the ip::tcp, ip::udp and ip::icmp classes.
* Fixed a compile error on some versions of g++ due to anonymous enums.
Refs #4883.
* Added an explicit cast to the FIONBIO constant to int to suppress a
compiler warning on some platforms. Refs #5128.
* Fixed warnings reported by g++'s -Wshadow compiler option. Refs #3905.
[SVN r69194]
workaround broke those platforms. Pragmas push_macro and pop_macro are only
available on gcc 4.4 or later, so use plain ol' #define/#undef instead.
[SVN r66289]
InternetProtocol::resolver_query and InternetProtocol::resolver_iterator,
as neither typedef is part of the documented InternetProtocol requirements.
The following typedefs are now marked as deprecated:
- ip::icmp::resolver_query
- ip::icmp::resolver_iterator
- ip::tcp::resolver_query
- ip::tcp::resolver_iterator
- ip::udp::resolver_query
- ip::udp::resolver_iterator
[SVN r60882]
prevent implicit conversion from int to flags, allowing the compiler to catch
cases where users incorrectly pass a numeric port number as the service name.
[SVN r60687]
This is to improve performance for very large numbers of asynchronous
operations and also to reduce memory usage for very small numbers. A new
macro BOOST_ASIO_HASH_MAP_BUCKETS may be used to tweak the sizes used for the
bucket arrays.
[SVN r52292]
- It is now evaluated before the first call to the underlying
*_some() operation, as well as after every operation.
- The return value is a number of bytes, which indicates the maximum
length to be transferred on the subsequent *_some() operation. If
the return value is 0 then the composed operation completes.
Add missing unit tests for read_at and write_at.
[SVN r48418]
