Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Revision History
PrevUpHomeNext

Asio 1.18.0 / Boost 1.74

  • Added an implementation of the proposed standard executors (P0443r13, P1348r0, and P1393r0).
  • Added support for the proposed standard executors to Asio's I/O facilities:
    • The io_context::executor_type, thread_pool::executor_type, system_executor, and strand executors now meet the requirements for the proposed standard executors. These classes also continue to meet the existing requirements for the Networking TS model of executors.
    • All I/O objects, asynchronous operations, and utilities including dispatch, post, defer, get_associated_executor, bind_executor, make_work_guard, spawn, co_spawn, async_compose, use_future, etc., can interoperate with both new proposed standard executors, and with existing Networking TS executors. The implementation determines at compile time which model a particular executor meets; the proposed standard executor model is used in preference if both are detected.
    • The any_io_executor type alias has been introduced as the new default runtime-polymorphic executor for all I/O objects. This type alias points to the execution::any_executor<> template with a set of supportable properties specified for use with I/O. This change may break existing code that directly uses the old polymorphic wrapper, executor. If required for backward compatibility, BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT can be defined, which changes the any_io_executor type alias to instead point to the executor polymorphic wrapper.
    • Support for the existing Networking TS model of executors can be disabled by defining BOOST_ASIO_NO_TS_EXECUTORS.
  • Added converting move construction and assignment to basic_waitable_timer. This enables move construction and assignment between different timer types, provided the executor types are convertible. For example:
    basic_waitable_timer<
        clock_type,
        traits_type,
        io_context::executor_type
      > timer1(my_io_context);
    
    basic_waitable_timer<
        clock_type,
        traits_type,
        any_io_executor // polymorphic wrapper
      > timer2(std::move(timer1));
    

  • Enabled C++20 coroutine support when using gcc 10.
  • Added overloads of co_spawn that launch an awaitable. This change allows us to write:
    co_spawn(executor,
        echo(std::move(socket)),
        detached);
    

    instead of:
    co_spawn(executor,
        [socket = std::move(socket)]() mutable
        {
          return echo(std::move(socket));
        },
        detached);
    

  • Added a new constructor overload to use_awaitable_t's default executor adapter, to enable conversion between executor types.
  • Added support for using detached_t as a default completion token, by adding members as_default_on() and as_default_on_t<>.
  • Added a move constructor to ssl::stream<>.
  • Changed ssl::stream<> write operations to linearise gather-write buffer sequences.
  • Added compile-time detection of the deprecated asio_handler_invoke hook. This hook was deprecated with the introduction of the Networking TS trait associated_executor and function get_associated_executor(). Compiling an application with BOOST_ASIO_NO_DEPRECATED will now trigger a compile error if any handler implements the asio_handler_invoke hook.
  • Added compile-time detection of the deprecated asio_handler_allocate and asio_handle_deallocate hooks. These hooks were deprecated with the introduction of the Networking TS trait associated_allocator and function get_associated_allocator(). Compiling an application with BOOST_ASIO_NO_DEPRECATED will now trigger a compile error if any handler implements the asio_handler_allocate or asio_handler_deallocate hooks.
  • Implemented a number of performance optimisations, including:
    • Specialising single-buffer operations to use recv rather than recvmsg, send rather than sendmsg, read rather than readv, and write rather than writev.
    • Lightening the reference counting overhead of the polymorphic wrapper executor.
    • Returning from system call operation wrappers as early as possible, and only accessing errno and error codes when on an error path.
    • Applying additional optimisations if a "native" I/O executor (such as io_context::exeutor_type) is detected.
  • Added source location support to handler tracking. The new BOOST_ASIO_HANDLER_LOCATION((file_name, line, function_name)) macro may be used to inform the handler tracking mechanism of a source location. This macro declares an object that is placed on the stack. Then, when an asynchronous operation is launched with location information, it outputs lines using the <action> n^m, prior to the n*m line that signifies the beginning of the asynchronous operation. For example:
    @asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5
    @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330)
    @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62)
    @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51)
    @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send
    @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5
    @asio|1589423304.861980|<7|
    

    If std::source_location or std::experimental::source_location are available, the use_awaitable_t token (when default-constructed or used as a default completion token) will also cause handler tracking to output a source location for each newly created asynchronous operation. A use_awaitable_t object may also be explicitly constructed with location information.
  • Implemented various improvements to the handlerviz.pl tool.
    • Add nodes for pending handlers at bottom of graph, outlined in red.
    • Display source location in a tooltip on the edge label (for SVG).
    • Use invisible nodes to enforce order to keep related control flow vertical.
  • Added the handlerlive.pl tool, which processes handler tracking output to produce a list of "live" handlers. Live handlers are those that are associated with pending asynchronous operations, as well as handlers that are currently executing. For example:
    cat output.txt | perl handlerlive.pl
    
    or:
    perl handerlive.pl < output.txt
    
    or:
    perl handlerlive.pl output.txt
    

  • Added the handlertree.pl tool, which filters handler tracking output to include only those events in the tree that produced the nominated handlers. For example, to filter the output to include only the events associated with handlers 123, 456, and their predecessors:
    cat output.txt | perl handlertree.pl 123 456
    
    or:
    perl handlertree.pl 123 456 < output.txt
    

    This script may be combined with handerlive.pl and handlerviz.pl to produce a graph of the "live" asynchronous operation chains. For example:
    cat output.txt | \
      perl handlertree.pl `perl handlerlive.pl output.txt` | \
      perl handlerviz.pl | \
      dot -Tsvg > output.svg
    

  • Added changes for clang-based Embarcadero C++ compilers.
  • Fixed a deadlock that can occur when multiple threads concurrently initialise the Windows I/O completion port backend.
  • Fixed async_compose to work with copyable handlers when passed by lvalue.
  • Fixed completion signature deduction in co_spawn.
  • Removed a spurious Executor base class from the executor_binder implementation.
  • Various fixes and improvements in the documentation and examples.

Asio 1.16.1 / Boost 1.73

  • Fixed compatibility with C++20 concept syntax.
  • Marked the POSIX descriptor classes' move constructors as noexcept.
  • Added the ssl::host_name_verification class, which is a drop-in replacement for ssl::rfc2818_verification. The ssl::rfc2818_verification class has been marked as deprecated. As a consequence of this change, SSL support now depends on functions that were introduced in OpenSSL 1.0.2.
  • Added an ssl::context constructor to take ownership of a native handle.
  • Changed C++ language version detection with gcc to use __cplusplus macro.
  • Fixed a work counting issue in the asynchronous resolve operation for endpoints.
  • Fixed the strand<> converting constructors and assignment operators.
  • Ensured that resolvers are restarted correctly after a fork.
  • Fixed compatibility with the current NetBSD release.
  • Removed spurious handler requirement checks in some async_read overloads.
  • Changed the ssl::context class to propagate non-EOF errors from the add_certificate_authority function.
  • Fixed a Windows-specific thread_pool destructor hang that occurred when the pool had an associated I/O object.
  • Changed the select reactor to recreate the "self pipe trick" sockets on error. This addresses an issue on some versions of Windows, where these sockets are discconected after a system sleep.
  • Fixed a compile error in the buffered streams due to the lack of reference collapsing in C++98.
  • Changed the priority_scheduler example to demonstrate calls to shutdown() and destroy().
  • Removed some unnecessary null pointer checks.
  • Changed Windows platform detection to recognise TV titles as Windows apps.
  • Added some emscripten compatibility patches.
  • Fixed a compile error in the use_awaitable_t::as_default_on function.
  • Changed all uses of the boost.bind placeholders to use the boost::placeholders namespace.
  • Fixed a potential compile error in the async_compose implementation due to incorrect overload selection.
  • Suppressed some non-virtual destructor warnings.
  • Various documentation fixes and improvements.

Asio 1.16.0 / Boost 1.72

  • Changed the async_initiate helper function to automatically deduce its return type. This is enabled for C++11 or later.
  • Changed all asynchronous operations to use automatically deduced return types. This allows completion token implementations to incorporate the asynchronous operation initiation into the initiating function's return type, without type erasure. Note that C++14 or later is required to support completion tokens that use per-operation return type deduction. For C++11 or earlier, a completion token's async_result specialisation must still provide the nested typedef return_type.
  • Introduced three new concepts to support async_initiate.
    • completion_signature<T>: Checks if T is a signature of the form R(Args...).
    • completion_handler_for<T, Signature>: Checks if T is usable as a completion handler with the specified signature.
    • completion_token_for<T, Signature>: Checks if T is a completion token that can be used with async_initiate and the specified signature.
    • For backward compatibility with pre-concepts C++, the macros BOOST_ASIO_COMPLETION_SIGNATURE, BOOST_ASIO_COMPLETION_HANDLER_FOR, and BOOST_ASIO_COMPLETION_TOKEN_FOR are provided. These macros expand to typename when concepts are unsupported.
  • Added the nested template type rebind_executor to all I/O object types, as a way to generically rebind them to use alternative I/O executors. For example:
    using my_socket_type = tcp::socket::rebind_executor<my_executor_type>::other;
    

  • Changed the asynchronous operations' initiation function objects to report their associated I/O executor via the nested type executor_type and member function get_executor(). Note that the presence of executor_type and get_executor() should be treated as optional, and consequently it may be preferable to access them via the associated_executor trait and the get_associated_executor() helper function.
  • Added the default_completion_token trait, so that every I/O executor type now has an associated default completion token type. This trait may be used in asynchronous operation declarations as follows:
    template <
        typename IoObject,
        typename CompletionToken =
          typename default_completion_token<
            typename IoObject::executor_type
          >::type
      >
    auto async_fyz(
        IoObject& io_object,
        CompletionToken&& token =
          typename default_completion_token<
            typename IoObject::executor_type
          >::type{}
      );
    

    If not specialised, this trait type is void, meaning no default completion token type is available for the given I/O executor.
  • Specialised the default_completion_token trait for the use_awaitable completion token, so that it may be used as shown in the following example:
    auto socket = use_awaitable.as_default_on(tcp::socket(my_context));
    // ...
    co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
    

    In this example, the type of the socket object is transformed from tcp::socket to have an I/O executor with the default completion token set to use_awaitable. Alternatively, the socket type may be computed directly:
    using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
    tcp_socket socket(my_context);
    // ...
    co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
    

  • Added missing async_initiate to the Windows-specific I/O objects' asynchronous operations.
  • Ensured that the executor type is propagated to newly accepted sockets. When synchronously or asynchronously accepting a new connection, but without specifying an executor or execution context, the accept operation will now correctly propagate the executor type from the acceptor to the socket. For example, if your acceptor type is:
    basic_socket_acceptor<ip::tcp, my_executor_type>
    

    then your accepted socket type will be:
    basic_stream_socket<ip::tcp, my_executor_type>
    

  • Changed to require that Protocol copy and move operations never throw.
  • Changed to require that Endpoint default constructor and move operations never throw.
  • Added the noexcept qualifier to protocol accessors.
  • Added the noexcept qualifier to socket move constructors.
  • Fixed issues associated with opening serial ports on Windows:
    • Use the correct constant to initialise the RTS control flag.
    • Specify a default baud rate (9600).
  • Fixed a lost "outstanding work count" that can occur when an asynchronous accept operation is automatically restarted.

Asio 1.14.1 / Boost 1.71

  • Improved performance slightly by eliminating a redundant move construction when completed handlers are dispatched.
  • Eliminated a compiler warning by annotating a case fall-through in the free function connect() implementation.
  • Fixed the is_*_buffer_sequence detection traits for user-defined sequence types.
  • Fixed some Windows-specific warnings about an incompatible pointer cast when obtaining the CancelIoEx entry point.
  • Changed to automatically set the defaults when opening a serial port on Windows.
  • Changed the serial port get_option() member function to be const.
  • Fixed a name hiding issue with the WinRT stream-oriented socket backend's shutdown function.
  • Applied a minor fix to the documentation for is_dynamic_buffer.
  • Added some support for Haiku OS.
  • Added wolfSSL compatability.
  • Changed to require C++17 or later for coroutines TS support with clang.
  • Fixed a doxygen generation problem in the tutorial.
  • Ensured example programs are correctly incorporated into the documentation.

Asio 1.14.0 / Boost 1.70

  • Added custom I/O executor support to I/O objects.
    • All I/O objects now have an additional Executor template parameter. This template parameter defaults to the asio::executor type (the polymorphic executor wrapper) but can be used to specify a user-defined executor type.
    • I/O objects' constructors and functions that previously took an asio::io_context& now accept either an Executor or a reference to a concrete ExecutionContext (such as asio::io_context or asio::thread_pool).
    • Note: One potential source of breakage in existing user code is when reusing an I/O object's io_context for constructing another I/O object, as in:
      asio::steady_timer my_timer(my_socket.get_executor().context());
      

      To fix this, either construct the second I/O object using the first I/O object's executor:
      asio::steady_timer my_timer(my_socket.get_executor());
      

      or otherwise explicitly pass the io_context:
      asio::steady_timer my_timer(my_io_context);
      

    • The previously deprecated get_io_context and get_io_service member functions have now been removed.
    • The previously deprecated service template parameters, and the corresponding classes, have now been removed.
  • Added a new async_result form with an initiate static member function.
    • The async_result template now supports a new form:
      template <typename CompletionToken, typename Signature>
      struct async_result
      {
        typedef /* ... */ return_type;
      
        template <typename Initiation,
            typename RawCompletionToken,
            typename... Args>
        static return_type initiate(
            Initiation&& initiation,
            RawCompletionToken&& token,
            Args&&... args);
      };
      

    • The initiate member function must: (a) transform the token into a completion handler object handler; (b) cause the invocation of the function object initiation as if by calling std::forward<Initiation>(initiation)(std::move(handler), std::forward<Args>(args)...). Note that the invocation of initiation may be deferred (e.g. lazily evaluated), in which case initiation and args must be decay-copied and moved as required.
    • A helper function template async_initiate has also been added as a wrapper for the invocation of async_result<>::initiate. For backward compatibility, this function supports both the old and new async_result forms.
    • The composed operations examples have been updated to use async_initiate.
    • The previously deprecated handler_type trait and single-argument form of async_result have now been removed.
  • Updated the Coroutines TS support and promoted it to the asio namespace.
    • The awaitable<>, co_spawn, this_coro, detached, and redirect_error facilities have been moved from the asio::experimental namespace to namespace asio. As part of this change, the this_coro::token() awaitable has been superseded by the asio::use_awaitable completion token.
    • Please note that the use_awaitable and redirect_error completion tokens work only with asynchronous operations that use the new form of async_result with member function initiate. Furthermore, when using use_awaitable, please be aware that the asynchronous operation is not initiated until co_await is applied to the awaitable<>.
  • Added a new DynamicBuffer_v2 concept which is CopyConstructible.
    • This change adds a new set of type requirements for dynamic buffers, DynamicBuffer_v2, which supports copy construction. These new type requirements enable dynamic buffers to be used as arguments to user-defined composed operations, where the same dynamic buffer object is used repeatedly for multiple underlying operations. For example:
      template <typename DynamicBuffer>
      void echo_line(tcp::socket& sock, DynamicBuffer buf)
      {
        n = asio::read_until(sock, buf, '\n');
        asio::write(sock, buf, asio::transfer_exactly(n));
      }
      

    • The original DynamicBuffer type requirements have been renamed to DynamicBuffer_v1. These requirements continue to be compatible with the Networking TS.
    • New type traits is_dynamic_buffer_v1 and is_dynamic_buffer_v2 have been added to test for conformance to DynamicBuffer_v1 and DynamicBuffer_v2 respectively. The existing is_dynamic_buffer trait has been retained and delegates to is_dynamic_buffer_v1 (unless BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is explicitly defined, in which case it delegates to is_dynamic_buffer_v2).
    • For convenience, the dynamic_string_buffer and dynamic_vector_buffer classes conform to both DynamicBuffer_v1 and DynamicBuffer_v2 requirements.
    • When BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is defined, all support for DynamicBuffer_v1 types and functions is #ifdef-ed out. Support for using basic_streambuf with the read, async_read, read_until, async_read_until, write, and async_write functions is also disabled as a consequence.
    • Note: This change should have no impact on existing source code that simply uses dynamic buffers in conjunction with Asio's composed operations.
  • Added a new async_compose function that simplifies the implementation of user-defined asynchronous operations.
  • Added a make_strand function, which creates a strand with a deduced Executor template argument.
  • Relaxed the completion condition type requirements to only require move-constructibility rather than copy-constructibility.
  • Added a constructor for local::basic_endpoint that takes a string_view.
  • Added the noexcept qualifier to various member functions of the ip::address, ip::address_v4, ip::address_v6, ip::basic_endpoint, and executor_work_guard classes.
  • Added the noexcept qualifier to the buffer_sequence_begin and buffer_sequence_end functions.
  • Added a new BOOST_ASIO_DISABLE_VISIBILITY configuration #define that allows visibility pragmas to be disabled. (Note: If symbols are hidden, extra care must be taken to ensure that Asio types are not passed across shared library API boundaries.)
  • Enabled recycling of the memory used to type-erase a function object with the polymorphic executor.
  • Changed receive operations to return the correct number of bytes transferred when truncation (error::message_size) occurs on a datagram-oriented socket.
  • Fixed multicast behaviour on QNX by automatically applying SO_REUSEPORT when the reuse_address option is set.
  • Added inclusion of unistd.h when targeting Haiku OS, to fix feature detection.
  • Added the network_v[46].hpp headers to the top-level convenience header.
  • Fixed calculation of absolute timeout when the backend uses pthread_cond_timedwait.
  • Changed the range-based asynchronous connect operation to deduce the EndpointSequence iterator type rather than assume the presence of a const_iterator typedef.
  • Fixed buffer_sequence_begin and buffer_sequence_end to prevent implicit conversion. This change addresses an issue where a call to buffer_sequence_begin or buffer_sequence_end could trigger an implicit conversion to const_buffer or mutable_buffer. Whenever this implicit conversion occurred, the return value of buffer_sequence_begin or buffer_sequence_end would point to a temporary object.
  • Ensured SSL handshake errors are propagated to the peer before the local operation completes.
  • Suppressed the eof error on SSL shutdown as it actually indicates success.
  • Added a fallback error code for when we OpenSSL produces an SSL_ERROR_SYSCALL result without an associated error.
  • Changed composed asynchronous read and write operations to move, rather than copy, the buffer sequence objects when the composed operation implementation is moved.
  • Changed to use <atomic> when targeting apple/clang/libc++ with recent Xcode versions, even for C++03. This fixes a warning about the deprecation of OSMemoryBarrier.
  • Fixed compile errors that occur when using the composed read and write operations with MSVC 11.0, by disabling decltype support for that compiler.
  • Increased the default value of _WIN32_WINNT to 0x0601 (Windows 7).
  • Fixed dispatch documentation to note that it may call the supplied function object in the current thread.
  • Updated post and defer documentation to clarify the the distinction between them.
  • Fixed compilation errors in the read and write composed operations when used with MSVC 11.0.
  • Fixed a Windows-specific issue where the execution context associated with system_executor was not being correctly cleaned up on exit.

Asio 1.12.2 / Boost 1.69

  • Fixed a problem with the detection of std::future availability with libstdc++.
  • Fixed compile error in regex overload of read_until.
  • Fixed a timer heap corruption issue that can occur when moving a cancelled timer.
  • Fixed detection of std::experimental::string_view and std::string_view with newer clang/libc++.
  • Fixed MSVC version detection for availability of std::invoke_result.
  • Fixed the buffer sequence traits to test the new requirements, if decltype is available.
  • Fixed an MSVC issue when building with exceptions disabled.
  • Added SSL context options for TLS v1.3.
  • Added a compile-time test for TLS v1 support.
  • Fixed the macro used to test for TLS v1.2 support.
  • Prevented global objects from being created once per thread on Windows.
  • Fixed a crash when using size(), max_size() or empty() on default-constructed resolver results.
  • Changed to move the return value in basic_resolver_results::begin() to avoid copying.
  • Enabled move support for the Intel Compiler.
  • Fixed std::string_view detection issue when using clang-cl.
  • Fixed the handler tracking operation name for io_context::executor_type::dispatch.
  • Fixed a buffer overflow that could occur when parsing an address string with a 64-bit scope id.
  • Added examples showing how to write composed operations.
  • Added C++11 versions of the Timeouts, Timers, SOCKS4 and SSL examples.
  • Fixed minor issues in documentation and examples.

Asio 1.12.1 / Boost 1.67

  • Added missing const qualifier to basic_socket_acceptor::get_option.
  • Worked around a parsing error that occurs with some versions of gcc.
  • Fixed broken code samples in tutorial.
  • Added new experimental features. (Note that "experimental" features may be changed without notice in subsequent releases.)
    • Added experimental::detached completion token.
    • Added experimental::redirect_error completion token.
    • Added experimental::co_spawn facility for integration with the coroutines technical specification.
  • Updated timeout examples to use latest features.
    • Used asio::steady_timer rather than asio::deadline_timer.
    • Used asio::dynamic_buffer rather than asio::streambuf.
    • Used timed asio::io_context::run_for() function for blocking clients.
    • Added example showing a custom completion token for blocking with timeouts.
  • Fixed unit tests to compile when BOOST_ASIO_NO_DEPRECATED is defined.
  • Changed socket iostreams to use chrono by default, to fix compatibility with the Networking TS. Define BOOST_ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM to enable the old Boost.Date_Time interface in basic_socket_streambuf and basic_socket_iostream.
  • Updated examples to use chrono rather than Boost.Date_Time.
  • Fixed an incorrect member function detector in the is_dynamic_buffer trait.
  • Fixed an async_result incompatibility with deprecated handler_type.
  • Added a missing move optimisation in the SSL stream implementation.
  • Fixed incorrect basic_resolver_results::value_type typedef.
  • Fixed a compile error with some OpenSSL versions when SSL_OP_NO_COMPRESSION is defined.
  • Changed add_certificate_authority to process multiple certificates in a bundle.
  • Eliminated deprecation warning with MSVC by using std::invoke_result rather than std::result_of.
  • Changed to use std::string_view for C++17 or later, and std::experimental::string_view for C++14. Define the preprocessor macro BOOST_ASIO_DISABLE_STD_STRING_VIEW to force the use of std::experimental::string_view (assuming it is available) when compiling in C++17 mode.
  • Ensured DynamicBuffer template arguments are decayed before using in enable_if tests.
  • Changed documentation to distinguish legacy completion handlers (which are still required to be CopyConstructible) from new MoveConstructible handlers.
  • Suppressed a discarded return value warning in the buffer debugging support.
  • Fixed basic_yield_context to work with completion signatures containing reference parameters.
  • Ensured that stackful coroutines launched using spawn() correctly store decayed copies of their function and handler arguments.
  • Fixed some compatibility issues with Android.
  • Added cross-compilation support to Jamfiles.
  • Fixed some minor portability issues in examples.

Asio 1.12.0 / Boost 1.66

  • Implemented interface changes to reflect the Networking TS (N4656).
    • See the list of new interfaces and, where applicable, the corresponding old interfaces that have been superseded.
    • The service template parameters, and the corresponding classes, are disabled by default. For example, instead of basic_socket<Protocol, SocketService> we now have simply basic_socket<Protocol>. The old interface can be enabled by defining the BOOST_ASIO_ENABLE_OLD_SERVICES macro.
  • Removed previously deprecated functions.
  • Added support for customised handler tracking.
  • Added reactor-related (i.e. descriptor readiness) events to handler tracking.
  • Added special concurrency hint values that may be used to disable locking on a per io_context basis.
  • Enabled perfect forwarding for the first ssl::stream<> constructor argument.
  • Added ability to release ownership of the underlying native socket. (Requires Windows 8.1 or later when using the I/O completion port backend.)

Asio 1.10.10 / Boost 1.65

  • Changed to require g++ versions >= 4.7 to use standard atomics, to fix a linker error when using g++ 4.6 (#13121).
  • Enabled use of constexpr and variadic templates with recent MSVC versions.
  • Fixed a race condition in the Linux epoll backend, which may occur when a socket or descriptor is closed while another thread is blocked on epoll.
  • Eliminated use of deprecated auto_ptr.
  • Fixed misplaced use of asio_handler_is_continuation result in reactive async_accept implementation.
  • Changed to use poll.h rather than sys/poll.h on some modern POSIX platforms (#12419).
  • Fixed MSVC intellisense detection.
  • Disabled use of the __thread keyword extension for android/clang/x86 targets.

Asio 1.10.9 / Boost 1.64

  • Added limited support for using regular file descriptors (where I/O operations should never fail with EAGAIN or EWOULDBLOCK) with posix::stream_descriptor, when using the Linux epoll backend.
  • Changed to use allocator_traits to rebind allocators in C++11 or later.
  • Eliminated a double "construction" issue in the converting move constructors.
  • Added new ssl::context_base enumerations to enable support for any TLS version, and improved consistency of SSL/TLS version handling across OpenSSL releases.
  • Applied more changes to address OpenSSL 1.1 compatibility.
  • Fixed a compile error when OpenSSL compression is disabled at compile time.
  • Suppressed some spurious unused variable warnings issued by gcc (#12302).
  • Worked around a new clang warning issued for usage of the comma operator.
  • Fixed various header ordering problems.
  • Changed to refer std::atomic_thread_fence, when available, to eliminate a deprecated function warning on newest macOS SDK (#12482).
  • Added a workaround for broken getaddrinfo in Apple's NAT64 environment.
  • Fixed an exception safety issue in the internal hash map implementation.

Asio 1.10.8 / Boost 1.62

  • Added compatibility with OpenSSL 1.1.0 (#12238).
  • Fixed out-of-bounds iterator use in asio::connect() when the connect_condition returns an end iterator (#12354).
  • Added a workaround for a move detection problem on MSVC 2015 Update 2 (#12115).
  • Changed a workaround that was previously added for broken Windows firewalls to only bind to 127.0.0.1 if getsockname reports 0.0.0.0 (#12406).
  • Added call to SSL_COMP_free_compression_methods to fix two memory leaks reported at shutdown, for OpenSSL versions >= 1.0.2 and < 1.1.0 (#10795).
  • Fixed use_future compile error encountered on some standard library implementations, by changing std::allocator<void> use to a non-void template parameter.
  • Enabled use of native getaddrinfo by default on Apple OSes, rather than emulation in terms of getipnodebyname.

Asio 1.10.7 / Boost 1.60

  • Added support for Windows 8.1 Store apps.
  • Fixed macro multiple definition error on Microsoft Visual Studio 2015 (#11539).
  • Changed Asio's SSL wrapper to respect OpenSSL's OPENSSL_NO_SSL3 feature test #define (#11754).
  • Changed Asio's SSL wrapper to use OpenSSL's new SSL_CTX_clear_chain_certs function, if available.
  • Suppressed a clang 3.6+ warning about unused typedefs (#11767).
  • Regenerated certificates used by SSL examples.
  • Fixed buffer sizes passed to strncat in the getaddrinfo emulation and in the SSL wrapper's password handling.
  • Changed Windows backend to use non-macro CreateEventW rather than CreateEvent (#11732).

Asio 1.10.6 / Boost 1.58

  • Ensured errors generated by Windows' ConnectEx function are mapped to their portable equivalents (#10744).
  • Added new macro BOOST_ASIO_DISABLE_CONNECTEX to allow use of ConnectEx to be explicitly disabled.
  • Fixed a race condition in windows::object_handle when there are pending wait operations on destruction (#10624).
  • Fixed IPv6 address parsing on FreeBSD, where a trailing scope ID would cause conversion to fail with EINVAL.
  • Worked around shared library visibility issues by ensuring Asio types use default visibility (#9465, #11070).
  • Changed the SSL wrapper to call the password callback when loading an in-memory key (#10828).
  • Fixed false SSL error reports by ensuring that the SSL error queue is cleared prior to each operation.
  • Fixed an ssl::stream<> bug that may result in spurious 'short read' errors.
  • Removed a redundant null pointer check in the SSL engine (#10088).
  • Added options for disabling TLS v1.1 and v1.2 (#10690).
  • Removed use of deprecated OpenSSL function ERR_remove_state.
  • Fixed detection of various C++11 features with Clang (#8835, #10884).
  • Fixed detection of C++11 std::addressof with g++ (#10982).
  • Changed multicast test to treat certain join_group failures as non-fatal.
  • Decoupled Asio unit tests from Boost.Test (#11116).
  • Changed the tutorial to use std::endl to ensure output is flushed.
  • Fixed an unsigned integer overflow reported by Clang's integer sanitizer.
  • Added support for move-only return types when using a yield_context object with asynchronous operations.
  • Changed yield_context to allow reentrant calls to the completion handler from an initiating function.
  • Updated detection of Windows Runtime to work with latest Windows SDK.

Asio 1.10.5 / Boost 1.57

  • Fixed the kqueue reactor so that it works on FreeBSD (#10606).
  • Fixed an issue in the kqueue reactor which resulted in spinning when using serial ports on Mac OS (#10496).
  • Fixed kqueue reactor support for read-only file descriptors (#10367).
  • Fixed a compile error when using the /dev/poll reactor (#10350, #10572).
  • Changed the Windows backend to use WSASocketW, as WSASocketA has been deprecated (#10534).
  • Fixed some warnings reported by Visual C++ 2013 (#10376).
  • Fixed integer type used in the WinRT version of the byte-order conversion functions (#10539).
  • Changed documentation to indicate that use_future and spawn() are not made available when including the asio.hpp convenience header (#10567).
  • Explicitly marked asio::strand as deprecated. Use asio::io_service::strand instead.

Asio 1.10.4 / Boost 1.56

  • Stopped using certain Winsock functions that are marked as deprecated in the latest Visual C++ and Windows SDK.
  • Fixed a shadow variable warning on Windows.
  • Fixed a regression in the kqueue backend that was introduced in Asio 1.10.2.
  • Added a workaround for building the unit tests with gcc on AIX.

Asio 1.10.3

  • Worked around a gcc problem to do with anonymous enums (#10042).
  • Reverted the Windows 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 (#10034).
  • Fixed an off-by-one error in the signal_set implementation's signal number check (#9324).
  • Changed the Windows IOCP backend to not assume that SO_UPDATE_CONNECT_CONTEXT is defined (#10016).
  • Fixed a Windows-specific issue, introduced in Asio 1.10.2, by using VerifyVersionInfo rather than GetVersionEx, as GetVersionEx has been deprecated.
  • Changed to use SSE2 intrinsics rather than inline assembly, to allow the Cray compiler to work.

Asio 1.10.2

  • Fixed asio::spawn() to work correctly with new Boost.Coroutine interface (#9442, #9928).
  • Ensured that incomplete asio::spawn() coroutines are correctly unwound when cleaned up by the io_service destructor (#9731).
  • Fixed delegation of continuation hook for handlers produced by io_service::wrap() and strand::wrap() (#9741).
  • Changed the Windows I/O completion port backend to use ConnectEx, if available, for connection-oriented IP sockets.
  • Changed the 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.
  • Prevented integer overflow when computing timeouts based on some boost::chrono and std::chrono clocks (#9662, #9778).
  • Made further changes to EV_CLEAR handling in the kqueue backend, to address other cases where the close() system call may hang on Mac OS X.
  • Fixed infinite recursion in implementation of resolver_query_base::flags::operator~ (#9548).
  • Made the select reactor more efficient on Windows for large numbers of sockets (#9528).
  • Fixed a Windows-specific type-aliasing issue reported by gcc (#9550).
  • Prevented execution of compile-time-only buffer test to avoid triggering an address sanitiser warning (#8295).
  • Disabled the GetQueuedCompletionStatus timeout workaround on recent versions of Windows.
  • Added support for string-based scope IDs when using link-local multicast addresses.
  • Changed IPv6 multicast group join to use the address's scope ID as the interface, if an interface is not explicitly specified.
  • Fixed multicast test failure on Mac OS X and the BSDs by using a link-local multicast address.
  • Various minor documentation improvements (#8295, #9605, #9771).

Asio 1.10.1 / Boost 1.55

  • Implemented a limited port to Windows Runtime. This support requires that the language extensions be enabled. Due to the restricted facilities exposed by the Windows Runtime API, the port also 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.
  • Fixed a regression (introduced in Boost 1.54) where, on some platforms, errors from async_connect were not correctly propagated through to the completion handler (#8795).
  • Fixed a Windows-specific regression (introduced in Boost 1.54) that occurs when multiple threads are running an 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).
  • Fixed a bug in handler tracking, where it was not correctly printing out some handler IDs (#8808).
  • Fixed the comparison used to test for successful synchronous accept operations so that it works correctly with unsigned socket descriptors (#8752).
  • Ensured the signal number is correctly passed to the completion handler when starting an async_wait on a signal that is already raised (#8738).
  • Suppressed a g++ 4.8+ warning about unused typedefs (#8980).
  • Enabled the move optimisation for handlers that use the default invocation hook (#8624).
  • Clarified that programs must not issue overlapping async_write_at operations (#8669).
  • Changed the Windows HANDLE backend to treat ERROR_MORE_DATA as a non-fatal error when returned by GetOverlappedResult for a synchronous read (#8722).
  • Visual C++ language extensions use generic as a keyword. Added a workaround that renames the namespace to cpp_generic when those language extensions are in effect.
  • Fixed some asynchronous operations that missed out on getting async_result support in Boost 1.54. In particular, the buffered stream templates have been updated so that they adhere to current handler patterns (#9000, #9001).
  • Enabled move support for Microsoft Visual Studio 2012 (#8959).
  • Added use_future support for Microsoft Visual Studio 2012.
  • Removed a use of std::min in the Windows IOCP backend to avoid a dependency on the <algorithm> header (#8758).
  • Eliminated some unnecessary handler copies.
  • Fixed support for older versions of OpenSSL that do not provide the SSL_CTX_clear_options function (#9273).
  • Fixed various minor and cosmetic issues in code and documentation (including #8347, #8950, #8953, #8965, #8997, #9230).

Asio 1.10.0 / Boost 1.54

  • Added new traits classes, handler_type and async_result, that allow the customisation of the return type of an initiating function.
  • Added the 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.
  • Added the 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.
  • Promoted the stackless coroutine class and macros to be part of Asio's documented interface, rather than part of the HTTP server 4 example. For further information, see Stackless Coroutines.
  • Added a new handler hook called 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.
  • Added four new generic protocol classes, 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.
  • Added C++11 move constructors that allow the conversion of a socket (or acceptor) into a more generic type. For example, an ip::tcp::socket can be converted into a generic::stream_protocol::socket via move construction. For further information, see Support for Other Protocols.
  • Extended the 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.
  • Moved existing examples into a C++03-specific directory, and added a new directory for C++11-specific examples. A limited subset of the C++03 examples have been converted to their C++11 equivalents.
  • Various SSL enhancements. Thanks go to Nick Jones, on whose work these changes are based.
    • Added support for SSL handshakes with re-use of data already read from the wire. New overloads of the 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.
    • Added support for creation of TLSv1.1 and TLSv1.2 ssl::context objects.
    • Added a set_verify_depth() function to the ssl::context and ssl::stream<> classes.
    • Added the ability to load SSL certificate and key data from memory buffers. New functions, 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.
    • Changed 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).
  • Fixed a potential deadlock in signal_set implementation.
  • Fixed an error in acceptor example in documentation #8421.
  • Fixed copy-paste errors in waitable timer documentation #8602.
  • Added assertions to satisfy some code analysis tools #7739.
  • Fixed a malformed #warning directive #7939.
  • Fixed a potential data race in the Linux epoll implementation.
  • Fixed a Windows-specific bug, where certain operations might generate an error_code with an invalid (i.e. NULL) error_category #8613.
  • Fixed basic_waitable_timer's underlying implementation so that it can handle any time_point value without overflowing the intermediate duration objects.
  • Fixed a problem with lost thread wakeups that can occur when making concurrent calls to run() and poll() on the same io_service object #8354.
  • Fixed implementation of asynchronous connect operation so that it can cope with spurious readiness notifications from the reactor #7961.
  • Fixed a memory leak in the ssl::rfc2818_verification class.
  • Added a mechanism for disabling automatic Winsock initialisation #3605. See the header file boost/asio/detail/winsock_init.hpp for details.

Asio 1.8.3 / Boost 1.53

  • Fixed some 64-to-32-bit conversion warnings (#7459).
  • Fixed some small errors in documentation and comments (#7761).
  • Fixed an error in the example embedded in basic_socket::get_option's documentation (#7562).
  • Changed to use long rather than int for SSL_CTX options, to match OpenSSL (#7209).
  • Changed to use _snwprintf to address a compile error due to the changed swprintf signature in recent versions of MinGW (#7373).
  • Fixed a deadlock that can occur on Windows when shutting down a pool of io_service threads due to running out of work (#7552).
  • Enabled the noexcept qualifier for error categories (#7797).
  • Changed UNIX domain socket example to treat errors from accept as non-fatal (#7488).
  • Added a small block recycling optimisation to improve default memory allocation behaviour.

Asio 1.8.2 / Boost 1.51

  • Fixed an incompatibility between ip::tcp::iostream and C++11 (#7162).
  • Decorated GCC attribute names with underscores to prevent interaction with user-defined macros (#6415).
  • Added missing #include <cctype>, needed for some versions of MinGW.
  • Changed to use gcc's atomic builtins on ARM CPUs, when available (#7140).
  • Changed strand destruction to be a no-op, to allow strand objects to be destroyed after their associated io_service has been destroyed.
  • Added support for some newer versions of glibc which provide the epoll_create1() function but always fail with ENOSYS (#7012).
  • Changed the SSL implementation to throw an exception if SSL engine initialisation fails (#6303).
  • Fixed another regression in buffered_write_stream (#6310).
  • Implemented various minor performance improvements, primarily targeted at Linux x86 and x86-64 platforms.

Asio 1.8.1 / Boost 1.50

  • Changed the epoll_reactor backend to do lazy registration for EPOLLOUT events.
  • Fixed the epoll_reactor handling of out-of-band data, which was broken by an incomplete fix in the last release.
  • Changed Asio's SSL wrapper to respect OpenSSL's OPENSSL_NO_ENGINE feature test #define (#6432).
  • Fixed windows::object_handle so that it works with Windows compilers that support C++11 move semantics (such as g++).
  • Improved the performance of strand rescheduling.
  • Added support for g++ 4.7 when compiling in C++11 mode (#6620).
  • Fixed a problem where signal_set handlers were not being delivered when the io_service was constructed with a concurrency_hint of 1 (#6657).

Asio 1.8.0 / Boost 1.49

  • Added a new class template 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.
  • Added a new 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.
  • On Linux, connect() can return EAGAIN in certain circumstances. Remapped this to another error so that it doesn't look like a non-blocking operation (#6048).
  • Fixed a compile error on NetBSD (#6098).
  • Fixed deadlock on Mac OS X (#6275).
  • Fixed a regression in buffered_write_stream (#6310).
  • Fixed a non-paged pool "leak" on Windows when an io_service is repeatedly run without anything to do (#6321).
  • Reverted earlier change to allow some speculative operations to be performed without holding the lock, as it introduced a race condition in some multithreaded scenarios.
  • Fixed a bug where the second buffer in an array of two buffers may be ignored if the first buffer is empty.

Asio 1.6.1 / Boost 1.48

  • Implemented various performance improvements, including:
    • Using thread-local operation queues in single-threaded use cases (i.e. when concurrency_hint is 1) to eliminate a lock/unlock pair.
    • Allowing some epoll_reactor speculative operations to be performed without holding the lock.
    • Improving 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.
    • Specialising asynchronous read and write operations for buffer sequences that are arrays (boost::array or std::array) of exactly two buffers.
  • Fixed a compile error in the regex overload of async_read_until (#5688).
  • Fixed a Windows-specific compile error by explicitly specifying the signal() function from the global namespace (#5722).
  • Changed the deadline_timer implementation so that it does not read the clock unless the timer heap is non-empty.
  • Changed the SSL stream's buffers' sizes so that they are large enough to hold a complete TLS record (#5854).
  • Fixed the behaviour of the synchronous null_buffers operations so that they obey the user's non-blocking setting (#5756).
  • Changed to set the size of the select fd_set at runtime when using Windows.
  • Disabled an MSVC warning due to const qualifier being applied to function type.
  • Fixed a crash that occurs when using the Intel C++ compiler (#5763).
  • Changed the initialisation of the OpenSSL library so that it supports all available algorithms.
  • Fixed the SSL error mapping used when the session is gracefully shut down.
  • Added some latency test programs.
  • Clarified that a read operation ends when the buffer is full (#5999).
  • Fixed an exception safety issue in epoll_reactor initialisation (#6006).
  • Made the number of strand implementations configurable by defining BOOST_ASIO_STRAND_IMPLEMENTATIONS to the desired number.
  • Added support for a new BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION flag which switches the allocation of strand implementations to use a round-robin approach rather than hashing.
  • Fixed potential strand starvation issue that can occur when strand.post() is used.

Asio 1.6.0 / Boost 1.47

  • 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 be registered with multiple signal_set objects, however the signal number must be used only with Asio. Addresses #2879.
  • 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).
  • 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, and are useful for creating TCP clients that work with both IPv4 and IPv6.
  • 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. This checking may be disabled by defining BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS.
  • Added a new, completely rewritten SSL implementation. The new implementation compiles faster, shows substantially improved performance, and supports custom memory allocation and handler invocation. It includes new API features such as certificate verification callbacks and has improved error reporting. The new implementation is source-compatible with the old for most uses. However, if necessary, the old implementation may still be used by defining BOOST_ASIO_ENABLE_OLD_SSL. Addresses #3702, #3958.
  • Changed the separate compilation support such that, to use Asio's SSL capabilities, you should also include boost/asio/ssl/impl/src.hpp in one source file in your program.
  • Changed the SSL implementation to support build environments where SSL v2 is explicitly disabled (#5453).
  • Made the is_loopback(), is_unspecified() and is_multicast() functions consistently available across the ip::address, ip::address_v4 and ip::address_v6 classes (#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.
  • Added the io_control() member function for socket acceptors (#3297).
  • Added a release() member function to posix descriptors. This function releases ownership of the underlying native descriptor to the caller. Addresses #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()).
  • 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 support for C++0x move construction and assignment to sockets, serial ports, POSIX descriptors and Windows handles.
  • Reduced the copying of handler function objects.
  • Added support for C++0x move construction to further reduce (and in some cases eliminate) copying of handler objects.
  • Added support for the 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. Addresses #3238, #4162.
  • Cleaned 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 the blocking mode and restart the call. If any other error occurs, assume the descriptor is closed. Addresses #3307.
  • Added new asio::buffer() overloads for std::array, when available.
  • Changed the implementation to use the C++0x standard library templates array, shared_ptr, weak_ptr and atomic when they are available, rather than the Boost equivalents.
  • Use C++0x variadic templates when available, rather than generating function overloads using Boost.Preprocessor.
  • Changed exception reporting to include the function name in exception what() messages.
  • Fixed insufficient initialisers warning with MinGW.
  • Changed the shutdown_service() member functions to be private.
  • Added archetypes for testing socket option functions.
  • Changed the Boost.Asio examples so that they don't use Boost.Thread's convenience header. Use the header file that is specifically for the boost::thread class instead.
  • Removed the dependency on OS-provided macros for the well-known IPv4 and IPv6 addresses. This should eliminate annoying "missing braces around initializer" warnings (#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 (#4971).
  • 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.
  • Modified the buffers_iterator<> and ip::basic_resolver_iterator classes so that the value_type typedefs are non-const byte types.
  • Fixed warnings reported by g++'s -Wshadow compiler option (#3905).
  • Added an explicit cast to convert the FIONBIO constant to int, to suppress a compiler warning on some platforms (#5128).
  • Changed most examples to treat a failure by an accept operation as non-fatal (#5124).
  • Fixed an error in the 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 (#5418).

Asio 1.4.9 / Boost 1.46.1

  • 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 (#5021).
  • Fixed compile failures with some versions of g++ due to the use of anonymous enums (#4883).
  • Fixed a bug on kqueue-based platforms, where some system calls that repeatedly fail with EWOULDBLOCK are not correctly re-registered with kqueue.
  • Changed asio::streambuf to ensure that its internal pointers are updated correctly after the data has been modified using std::streambuf member functions.
  • Fixed a bug that prevented the linger socket option from working on platforms other than Windows.

Asio 1.4.8 / Boost 1.46

  • Fixed an integer overflow problem that occurs when ip::address_v4::broadcast() is used on 64-bit platforms.
  • Fixed a problem on older Linux kernels (where epoll is used without timerfd support) that prevents timely delivery of deadline_timer handlers, after the program has been running for some time (#5045).

Asio 1.4.7 / Boost 1.45

  • Fixed a problem on kqueue-based platforms where a deadline_timer may never fire if the io_service is running in a background thread (#4568).
  • Fixed a const-correctness issue that prevented valid uses of has_service<> from compiling (#4638).
  • Fixed MinGW cross-compilation (#4491).
  • Removed dependency on deprecated Boost.System functions (#4672).
  • Ensured close()/closesocket() failures are correctly propagated (#4573).
  • Added a check for errors returned by InitializeCriticalSectionAndSpinCount (#4574).
  • Added support for hardware flow control on QNX (#4625).
  • Always use pselect() on HP-UX, if it is available (#4578).
  • Ensured handler arguments are passed as lvalues (#4744).
  • Fixed Windows build when thread support is disabled (#4680).
  • Fixed a Windows-specific problem where deadline_timer objects with expiry times set more than 5 minutes in the future may never expire (#4745).
  • Fixed the resolver backend on BSD platforms so that an empty service name resolves to port number 0, as per the documentation (#4690).
  • Fixed read operations so that they do not accept buffer sequences of type const_buffers_1 (#4746).
  • Redefined Protocol and id to avoid clashing with Objective-C++ keywords (#4191).
  • Fixed a vector reallocation performance issue that can occur when there are many active deadline_timer objects (#4780).
  • Fixed the kqueue backend so that it compiles on NetBSD (#4662).
  • Fixed the socket io_control() implementation on 64-bit Mac OS X and BSD platforms (#4782).
  • Fixed a Windows-specific problem where failures from accept() are incorrectly treated as successes (#4859).
  • Deprecated the separate compilation header <boost/asio/impl/src.cpp> in favour of <boost/asio/impl/src.hpp> (#4560).

Asio 1.4.6 / Boost 1.44

  • Reduced compile times. (Note that some programs may need to add additional #includes, e.g. if the program uses boost::array but does not explicitly include <boost/array.hpp>.)
  • Reduced the size of generated code.
  • Refactored deadline_timer implementation to improve performance.
  • Improved multiprocessor scalability on Windows by using a dedicated hidden thread to wait for timers.
  • Improved performance of 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.
  • Added optional separate compilation. To enable, add #include <boost/asio/impl/src.cpp> to 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.
  • Added new macro BOOST_ASIO_DISABLE_FENCED_BLOCK to permit the disabling of memory fences around completion handlers, even if thread support is enabled.
  • Reworked timeout examples to better illustrate typical use cases.
  • Ensured that handler arguments are passed as const types.
  • Fixed incorrect parameter order in null_buffers variant of async_send_to (#4170).
  • Ensured unsigned char is used with isdigit in getaddrinfo emulation (#4201).
  • Fixed handling of very small but non-zero timeouts (#4205).
  • Fixed crash that occurred when an empty buffer sequence was passed to a composed read or write operation.
  • Added missing operator+ overload in buffers_iterator (#4382).
  • Implemented cancellation of null_buffers operations on Windows.

Asio 1.4.5 / Boost 1.43

  • Improved performance.
  • Reduced compile times.
  • Reduced the size of generated code.
  • Extended the guarantee that background threads don't call user code to all asynchronous operations (#3923).
  • Changed to use edge-triggered epoll on Linux.
  • Changed to use timerfd for dispatching timers on Linux, when available.
  • Changed to use one-shot notifications with kqueue on Mac OS X and BSD platforms.
  • Added a bitmask type 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.
  • Added #define NOMINMAX for all Windows compilers. Users can define BOOST_ASIO_NO_NOMINMAX to suppress this definition (#3901).
  • Fixed a bug where 0-byte asynchronous reads were incorrectly passing an error::eof result to the completion handler (#4023).
  • Changed the io_control() member functions to always call ioctl on the underlying descriptor when modifying blocking mode (#3307).
  • Changed the resolver implementation to longer require the typedefs 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.
  • Fixed out-of-band handling for reactors not based on select().
  • Added new BOOST_ASIO_DISABLE_THREADS macro that allows Asio's threading support to be independently disabled.
  • Minor documentation improvements.

Asio 1.4.4 / Boost 1.42

  • Added a new HTTP Server 4 example illustrating the use of stackless coroutines with Asio.
  • Changed handler allocation and invocation to use boost::addressof to get the address of handler objects, rather than applying operator& directly (#2977).
  • Restricted MSVC buffer debugging workaround to 2008, as it causes a crash with 2010 beta 2 (#3796, #3822).
  • Fixed a problem with the lifetime of handler memory, where Windows needs the OVERLAPPED structure to be valid until both the initiating function call has returned and the completion packet has been delivered.
  • Don't block signals while performing system calls, but instead restart the calls if they are interrupted.
  • Documented the guarantee made by strand objects with respect to order of handler invocation.
  • Changed strands to use a pool of implementations, to make copying of strands cheaper.
  • Ensured that kqueue support is enabled for BSD platforms (#3626).
  • Added a boost_ prefix to the extern "C" thread entry point function (#3809).
  • In 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.
  • Added a workaround for some broken Windows firewalls that make a socket appear bound to 0.0.0.0 when it is in fact bound to 127.0.0.1.
  • Applied a fix for reported excessive CPU usage under Solaris (#3670).
  • Added some support for platforms that use older compilers such as g++ 2.95 (#3743).

Asio 1.4.3 / Boost 1.40

  • Added a new ping example to illustrate the use of ICMP sockets.
  • Changed the 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.
  • Changed some instances of the 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 (#2754).
  • Made Asio compatible with the OpenSSL 1.0 beta (#3256).
  • Eliminated a redundant system call in the Solaris /dev/poll backend.
  • Fixed a bug in resizing of the bucket array in the internal hash maps (#3095).
  • Ensured correct propagation of the error code when a synchronous accept fails (#3216).
  • Ensured correct propagation of the error code when a synchronous read or write on a Windows HANDLE fails.
  • Fixed failures reported when _GLIBCXX_DEBUG is defined (#3098).
  • Fixed custom memory allocation support for timers (#3107).
  • Tidied up various warnings reported by g++ (#1341, #2618).
  • Various documentation improvements, including more obvious hyperlinks to function overloads, header file information, examples for the handler type requirements, and adding enum values to the index (#3157, #2620).

Asio 1.4.2 / Boost 1.39

  • Implement automatic resizing of the bucket array in the internal hash maps. 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. (N.B. this feature introduced a bug which was fixed in Asio 1.4.3 / Boost 1.40.)
  • Add performance optimisation for the Windows IOCP backend for when no timers are used.
  • Prevent locale settings from affecting formatting of TCP and UDP endpoints (#2682).
  • Fix a memory leak that occurred when an asynchronous SSL operation's completion handler threw an exception (#2910).
  • Fix the implementation of io_control() so that it adheres to the documented type requirements for IoControlCommand (#2820).
  • Fix incompatibility between Asio and ncurses.h (#2156).
  • On Windows, specifically handle the case when an overlapped 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 (#2936).
  • Fix system call wrappers to always clear the error on success, as POSIX allows successful system calls to modify errno (#2953).
  • Don't include termios.h if BOOST_ASIO_DISABLE_SERIAL_PORT is defined (#2917).
  • Cleaned up some more MSVC level 4 warnings (#2828).
  • Various documentation fixes (#2871).

Asio 1.4.1 / Boost 1.38

  • Improved compatibility with some Windows firewall software.
  • Ensured arguments to windows::overlapped_ptr::complete() are correctly passed to the completion handler (#2614).
  • Fixed a link problem and multicast failure on QNX (#2504, #2530).
  • Fixed a compile error in SSL support on MinGW / g++ 3.4.5.
  • Drop back to using a pipe for notification if eventfd is not available at runtime on Linux (#2683).
  • Various minor bug and documentation fixes (#2534, #2541, #2607, #2617, #2619).

Asio 1.4.0 / Boost 1.37

  • Enhanced CompletionCondition concept with the signature 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).
  • New windows::overlapped_ptr class to allow arbitrary overlapped I/O functions (such as TransmitFile) to be used with Asio.
  • On recent versions of Linux, an eventfd descriptor is now used (rather than a pipe) to interrupt a blocked select/epoll reactor.
  • Added const overloads of lowest_layer().
  • Synchronous read, write, accept and connect operations are now thread safe (meaning that it is now permitted to perform concurrent synchronous operations on an individual socket, if supported by the OS).
  • Reactor-based io_service implementations now use lazy initialisation to reduce the memory usage of an io_service object used only as a message queue.

Asio 1.2.0 / Boost 1.36

  • Added support for serial ports.
  • Added support for UNIX domain sockets.
  • Added support for raw sockets and ICMP.
  • Added wrappers for POSIX stream-oriented file descriptors (excluding regular files).
  • Added wrappers for Windows stream-oriented HANDLEs such as named pipes (requires HANDLEs that work with I/O completion ports).
  • Added wrappers for Windows random-access HANDLEs such as files (requires HANDLEs that work with I/O completion ports).
  • Added support for reactor-style operations (i.e. they report readiness but perform no I/O) using a new null_buffers type.
  • Added an iterator type for bytewise traversal of buffer sequences.
  • Added new read_until() and async_read_until() overloads that take a user-defined function object for locating message boundaries.
  • Added an experimental two-lock queue (enabled by defining BOOST_ASIO_ENABLE_TWO_LOCK_QUEUE) that may provide better io_service scalability across many processors.
  • Various fixes, performance improvements, and more complete coverage of the custom memory allocation support.

Asio 1.0.0 / Boost 1.35

First release of Asio as part of Boost.


PrevUpHomeNext