[/
 / Copyright (c) 2003-2025 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 /
 / Distributed under the Boost Software License, Version 1.0. (See accompanying
 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 /]

[section:history Revision History]

[heading Asio 1.38.0 / Boost 1.90]

* Changed the macro-based coroutine implementation to ensure that case labels
  are deterministic when __COUNTER__ is used.
* Fixed synchronous SSL stream `shutdown` to remap `error::eof` as
  `async_shutdown` does.
* Fixed a warning caused by the newly added `[[deprecated]]` attribute, when
  compiling for C++11.
* Changed `stream_file` and `random_access_file` on Windows to treat the
  supplied file path as a UTF-8 encoded string.
* Added checks to `experimental::parallel_group` and
  `experimental::ranged_parallel_group` to detect when they are incorrectly
  called with an empty set of asynchronous operations.
* Removed the previously added workaround for `_FORTIFY_SOURCE`, and instead
  added additional address length checking into `ip::basic_resolver_results`.
* Fixed `experimental::coro` to add protection against `max` as a macro.
* Updated the detection of std::aligned_alloc to work with newer versions of
  [^libc++].
* Various documentation fixes and improvements.

[heading Asio 1.37.0]

* Added the `execution::inline_exception_handling` property. This property is
  used to describe what guarantees an executor makes about the treatment of
  exceptions that are thrown by a submitted function, when that function is
  executed inline within `execute`.
* Added `inline_executor`, an executor that always executes the function object
  inline. An `inline_executor` is suitable as a completion executor, but cannot
  be used as an I/O executor.
* Changed the default candidate executor for `associated_executor` from
  `system_executor` to `inline_executor`.
* Added `inline_or_executor<>` and the `inline_or()` helper function. The
  `inline_or_executor<>` template is an executor adapter. It attempts to execute
  submitted function objects inline when permitted, and otherwise posts the
  function object to the wrapped executor.
* Added overloads of `dispatch`, `post` and `defer` that take a function object
  to be run on the target executor, and deliver the result to the completion
  handler:[br]
  ``
    asio::post(
      []{
        // ... perform long running computation ...
        return result;
      },
      my_thread_pool,
      asio::bind_executor(my_io_context,
        [](int result)
        {
          // ...
        }));
  ``[br]
  Or, if called from a coroutine using the default `asio::deferred` completion
  token:[br]
  ``
    int result = co_await asio::post(
      []{
        // perform long running computation
        return result;
      }, my_thread_pool);
  ``
* Added the `redirect_disposition` completion token adapter, as a generic
  counterpart for `redirect_error`. The `redirect_disposition` adapter is used
  to capture the disposition (such as an `error_code`) that is produced by an
  asynchronous operation into a variable:[br]
  ``
  std::exception_ptr my_exception;
  // ...
  my_socket.async_read_some(my_buffer,
      boost::asio::redirect_disposition(
        [](std::size_t bytes_transferred)
        {
          // ...
        }, my_exception));
  ``
* Annotated deprecated items with the `[[deprecated]]` attribute.
* Added a new configuration parameter "reactor" / "reset_edge_on_partial_read".
  When true, a partial read on a stream-oriented socket is treated as consuming
  the edge-triggered readiness notification, requiring a new readiness event
  before further reads. (Partial writes always consume the edge.) This avoids
  unnecessary speculative reads. Defaults to `false`.
* Added a new configuration parameter "reactor" / "use_eventfd" that is used
  to determine whether the [^epoll] reactor backend uses `eventfd`. Defaults
  to `true`.
* Added a new configuration parameter "reactor" / "use_timerfd" that is used
  to determine whether the [^epoll] reactor backend uses `timerfd`. Defaults
  to `true`.
* Implemented a compile-time feature check for standard library support for
  `std::source_location`, in addition to `std::experimental::source_location`.
* Stopped using the deprecated function `boost::array::c_array()`.
* Added a missing preprocessor check for `BOOST_ASIO_DISABLE_TIMERFD`.
* Fixed a resource leak in `asio::awaitable` move assignment.
* Fixed a memory leak in `ssl` stream move assignment.
* Fixed a thread sanitizer issue in the [^kqueue] reactor.
* Fixed handler tracking arguments passed in the `io_uring` backend.
* Fixed an unused parameter warning `boost::asio::detail::null_thread`.

[heading Asio 1.36.0 / Boost 1.89]

* Fixed an issue, introduced in Asio 1.35.0, that prevented the creation of
  internal threads required for running some asynchronous operations on a
  `thread_pool`.
* Fixed `co_spawn` to adhere to the asynchronous operation requirement for
  non-reentrant invocation of the completion handler.
* Added the `[[noreturn]]` attribute to `boost::asio::detail::throw_exception`.
* Fixed compilation errors in `channel<void(error_code)>` and
  `concurrent_channel<void(error_code)>`.
* Fixed a compilation issue with the Bullseye compiler.
* Fixed an `awaitable` coroutine compile error with the clang shipped with MSVC.
* Fixed support for platforms that don't define `SA_NOCLDWAIT`.
* Worked around a warning that occurs when building with `_FORTIFY_SOURCE` on
  recent [^g++].
* Added a documentation note on `basic_signal_set` async signal safety.

[heading Asio 1.35.0]

* Added allocator constructors to `execution_context`, `io_context` and
  `thread_pool`. The supplied allocator is used for allocating objects
  associated with the execution context, such as services, the internal state
  for I/O objects like sockets or timers, and strands. The allocator may also be
  accessed by user code via the `execution_context::allocator<>` class template.
* Extended the allocation example to cover `execution_context` allocation.
* Added a new configuration parameter "timer" / "heap_reserve" that may be
  used to reserve space in the vector used for a timer queue's heap. This may
  be used to preallocate sufficient space such that the creation of new timers
  does not trigger further allocations.
* Added a new configuration parameter "resolver" / "threads" that is used to
  specify the number of internal threads used by `async_resolve` to emulate
  asynchronous address resolution. If this is set to a non-zero value, that
  number of threads will be created when the first resolver object is
  constructed. Otherwise, it defaults to a single thread that is created on the
  first call to async_resolve.
* Removed `deadline_timer`, `basic_deadline_timer` and `time_traits` from the
  convenience header [^boost/asio.hpp].
* Ensured that the Windows named pipes created by `connect_pipe` use unique
  names that don't conflicting if Asio is used in multiple, independent plug-in
  DLLs.
* Changed `BOOST_ASIO_CONCURRENCY_HINT_SAFE` to be consistent with the
  `io_context` default constructor.
* Fixed the documentation for `BOOST_ASIO_CONCURRENCY_HINT_UNSAFE_IO` to reflect
  that registration locking is still enabled.
* Added separate [^b2] and [^cmake] build targets for optional dependencies.
* Fixed a build error in the serialization example.
* Fixed some shadow variable warnings.

[heading Asio 1.34.2 / Boost 1.88]

* Fixed an ambiguous overload issue that occurred when passing a `std::span` to
  the `boost::asio::buffer` function.
* Added overview documentation on the available runtime configuration options.
* Updated the overview documentation to reflect the use of `deferred` as the
  default completion token.
* Updated the `async_result` documentation to reflect the current type
  requirements placed on specialisations of the trait.

[heading Asio 1.34.1]

* Added `noexcept` qualifiers to various `local::basic_endpoint` member
  functions, to make it consistent with `ip::basic_endpoint`.
* Fixed the `boost::asio::config` class's handling of integer values.
* Fixed a use-after-move error in `experimental::ranged_parallel_group`.
* Fixed an incorrect default template argument in the implementation of
  `experimental::promise`.
* Fixed the `io_uring` implementation so that it does not attempt to
  re-register internal descriptors with the reactor after a fork, if they
  were not previously registered.
* Fixed an uninitialised member in the `thread_pool` default constructor.
* Removed some spurious macro definitions that were left after the removal
  of deprecated buffer functionality.
* Added documentation to clarify the use of `file_base::flags` when opening
  a file.

[heading Asio 1.34.0 / Boost 1.87]

* Relaxed disposition requirements to require only nothrow move, rather than
  copy.
* Fixed compile error when threading support is disabled.
* Fixed compile error when `BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING` is
  defined.
* Fixed compile error when using Clang 19.
* Changed `thread_pool::join()` to ensure that it stops threads that are
  subsequently added to the pool using `thread_pool::attach()`.
* Fixed the offsets passed to `io_uring_prep_write_fixed` and
  `io_uring_prep_read_fixed`, when they are used for stream-oriented operations.

[heading Asio 1.33.0]

* Added support for using byte spans and sequences of byte spans as buffer
  sequences. This means that they can be passed directly to I/O operations such
  as `async_read`.
* Added support for dispositions, which are types that can be used to test
  whether an asynchronous operation completed without error. This includes
  `error_code` and `exception_ptr`, but can be extended to user types via
  specialisation of the `disposition_traits` class template. Generic code that
  is intended to work in terms of dispositions should not use
  `boost::asio::disposition_traits` directly, but instead:
  * Test whether a disposition holds no error by comparing against
    `boost::asio::no_error` (of type `boost::asio::no_error_t`).
  * Use `boost::asio::to_exception_ptr` to convert a disposition to a
    `std::exception_ptr`.
  * Use `boost::asio::throw_exception` to throw an exception that corresponds to
    the disposition, after first testing the disposition against
    `boost::asio::no_error`.
* Added disposition support to the `boost::asio::use_future` completion token,
  `boost::asio::awaitable<>`-based coroutines, `boost::asio::spawn()`, and
  `boost::asio::experimental::cancellation_condition`.
* Added the `execution_context::service_maker` abstract base class. A
  `service_maker` is an object that is passed to an execution context's
  constructor, and allows services to be added at context construction time.
  Additional constructor overloads have been added to `io_context` and
  `thread_pool` that accept a `service_maker`.
* Added `boost::asio::config`. The `config` class provides access to
  configuration parameters that are associated with an execution context. The
  class is intended for use by asio internals, or by libraries or user-provided
  abstractions that build on top of asio. These configuration parameters will
  typically be used to fine tune behaviour, such as enabling or disabling
  certain optimisations. When constructing an execution context, such as an
  `io_context`, the caller may optionally pass a `service_maker` to install a
  concrete configuration service into the context. For example:[br]
  ``
    boost::asio::io_context ctx{boost::asio::config_from_env{}};
  ``
  The configuration parameters' values are accessed using the `config` class,
  passing a section, key and default value:[br]
  ``
    boost::asio::config cfg{ctx};
    bool enable_locking = cfg.get("scheduler", "locking", true);
  ``
* Added an initial set of configuration parameters recognised by asio's
  `io_context` and `thread_pool` implementations:
  * "scheduler" / "concurrency_hint" (int, default `0`) - A suggestion to the
    scheduler of how many active should be used for running completion handlers.
  * "scheduler" / "locking" (bool, default `true`) - May be set to `false` to
    disable locking in the scheduler, in which case care must be taken not to
    perform concurrent operations on the execution context or its I/O objects.
  * "scheduler" / "locking_spin_count" (int, default `0`) - The number of times
    to first attempt to acquire the lock without blocking.
  * "scheduler" / "task_usec" (long, default `-1`) - The maximum time that the
    scheduler will wait for its reactor task to complete.
  * "scheduler" / "wait_usec" (long, default `-1`) - The maximum time that the
    scheduler will wait on its wakeup event in an idle thread.
  * "reactor" / "preallocated_io_objects" (unsigned int, default `0`) - The
    number of internal reactor I/O object states to allocate at construction.
  * "reactor" / "registration_locking" (bool, default `true`) - May be set to
    `false` to disable locking in the reactor around I/O object registration,
    in which case care must be taken not to concurrently open or close I/O 
    objects.
  * "reactor" / "registration_locking_spin_count" (int, default `0`) - The
    number of times to first attempt to acquire the lock without blocking.
  * "reactor" / "io_locking" (bool, default `true`) - May be set to `false` to
    disable per I/O object locking in the reactor, in which case the execution
    context must be single-threaded and care must be taken not to perform
    concurrent calls to I/O operations' initiating functions.
  * "reactor" / "io_locking_spin_count" (int, default `0`) - The number of times
    to first attempt to acquire the lock without blocking.
* Removed some previously deprecated facilities:
  * Removed Boost.Coroutine-based `spawn()` overloads. The `spawn()` function
    now works only with the fiber support in Boost.Context.
  * Removed deprecated `asio::connect` overloads.
  * Removed deprecated `ip::address_v4` member functions.
  * Removed deprecated `ip::address_v6` member functions.
  * Removed deprecated constant `socket_base::max_connections`.
  * Removed deprecated classes `const_buffers_1` and `mutable_buffers_1`.
  * Removed deprecated function `buffer_cast`.
  * Removed deprecated `use_future_t::operator[]`.
  * Removed deprecated alias `experimental::append`.
  * Removed deprecated alias `experimental::prepend`.
  * Removed deprecated alias `experimental::as_tuple`.
  * Removed deprecated alias `experimental::deferred`.
  * Removed deprecated class `ssl::rfc2818_verification`.
  * Removed deprecated alias `io_service`.
  * Removed deprecated class `io_context::work`.
  * Removed deprecated `io_context` ['run functions].
  * Removed deprecated function `io_context::reset`.
  * Removed deprecated `io_context::service` member functions.
  * Removed deprecated `dispatch` and `post` members from `io_context` andxi
    `io_context::strand`.
* Deprecated `basic_io_object`.
* Deprecated `deadline_timer` and associated types.
* Added rvalue-qualified `operator()` overloads to associating binders.
* Added support for modular build structure.
* Fixed `spawn()` of functions that return move-only types.
* Fixed `co_composed` to not require concepts support.
* Fixed the epoll reactor to not try to re-register regular file descriptors
  after fork.
* Fixed a leak in `ssl::detail::engine` move assignment.

[heading Asio 1.32.0 / Boost 1.86]

* Fixed an issue in `co_composed` caused by a missing `decay`.
* Fixed an issue in `co_composed` due to a missing reference in a cast to a base
  class type.
* Changed to use the standard C++20 coroutine feature test macro by default.
* Changed to use `std::aligned_alloc` on Android, when available.
* Fixed an integer conversion warning in `ip::address_v6`, on iOS/tvOS.
* Added missing include of `<malloc.h>` required for `_alloca`.
* Changed to use a standard feature test macro to check if the standard library
  supports `std::invoke_result`.
* Fixed handling of `file_base::append` in Windows file support.
* Fixed some warnings in IP address to string conversion.
* Added support for using `co_spawn` when exceptions are disabled.
* Fixed `spawn.hpp` header to be self-contained.
* Enabled TLS v1.3 options for WolfSSL.
* Fixed `experimental::coro` implementation to use the correct cancellation
  slot.
* Fixed `io_context::strand::wrap()` so that its return value has an associated
  executor.
* Marked `constexpr` global variables as `inline`.
* Documentation fixes.

[heading Asio 1.31.0]

* Changed the `default_completion_token` trait's primary template to select
  `deferred` as the default completion token. As a result, most asynchronous
  operations' initiating functions will return a deferred asynchronous operation
  by default. For example, the completion token can be omitted when calling
  asynchronous operations from an `awaitable` coroutine:[br]
  ``
  awaitable<void> echo(ip::tcp::socket& my_socket)
  {
    char data[1024];
    for (;;)
    {
      std::size_t n = co_await my_socket.async_read_some(buffer(data));
      co_await async_write(my_socket, buffer(data, n));
    }
  }
  ``
  or when using an operation that accepts asynchronous operations as function
  objects, such as `experimental::make_parallel_group`:[br]
  ``
  experimental::make_parallel_group(
      my_socket.async_read_some(buffer(data)),
      my_timer.async_wait()
    ).async_wait(/* ... */);
  ``
* Added the `is_completion_condition` trait and used it to add the missing
  default completion tokens to overloads of `async_read`, `async_read_at`,
  `async_write`, and `async_write_at`.
* Added the `is_connect_condition` trait and used it disambiguate overloads of
  `async_connect` when the completion token is defaulted.
* Extended the completion token adapters `as_tuple`, `bind_allocator`,
  `bind_cancellation_slot`, `bind_executor`, `bind_immediate_executor`, and
  `redirect_error` to allow them to be used as ['partial completion token
  adapters]. This means that they can be created without explicitly supplying a
  completion token. Instead, when the adapter is passed to an asynchronous
  operation, it will automatically determine the operation's default completion
  token and adapt it. For example, the expression:[br]
  ``
  my_socket.async_read_some(my_buffer, as_tuple)
  ``
  will return a deferred asynchronous operation with the completion arguments
  packaged in a tuple. They may also be applied using the `deferred` operations'
  pipe operator:[br]
  ``
  error_code e;
  co_await (async_write(my_socket, my_buffer) | redirect_error(e));
  ``
* Added the `cancel_after` and `cancel_at` completion token adapters. These
  may be used to adapt any asynchronous operation to emit a cancellation signal
  after a specified duration or at an absolute time point. For example:[br]
  ``
  my_socket.async_read_some(my_buffer,
      cancel_after(std::chrono::seconds(10),
        [](error_code e, std::size_t n)
        {
          // ...
        }));
  ``
  This cancellation is implemented internally using a `basic_waitable_timer`.
  By default, this timer is created using the asynchronous operation's I/O
  executor. If the operation does specify its I/O executor, a timer may be
  explicitly supplied:[br]
  ``
  my_socket.async_read_some(my_buffer,
      cancel_after(my_timer, std::chrono::seconds(10),
        [](error_code e, std::size_t n)
        {
          // ...
        }));
  ``
  These adapters may also be used as partial completion token adapters, as
  in:[br]
  ``
  co_await my_socket.async_read_some(my_buffer, cancel_after(5s));
  ``
  or:[br]
  ``
  co_await (
      async_write(my_socket, my_buffer) | as_tuple
        | cancel_after(std::chronos::seconds(10)
    );
  ``
  or to adapt other partial completion token adapters:[br]
  ``
  co_await my_socket.async_read_some(my_buffer, cancel_after(5s, as_tuple));
  ``
  Note that, since the implementation in terms of a timer introduces a parallel
  `async_wait` operation, it is the responsibility of the caller to ensure that
  the asynchronous operation is performed in an implicit or explicit strand.
* Changed all completion token adapters to ensure they correctly propagate the
  asynchronous operation's I/O executor during adaptation.
* Fixed `async_compose` and `co_composed` to correctly indicate if they have
  an I/O executor.
* Moved `co_composed` out of the `experimental` namespace.
* Added `composed`, which creates an initiation function object from a stateful
  implementation. It is similar to `co_composed`, but for regular function
  objects rather than C++20 coroutines. For example:
  ``
  struct async_echo_implementation
  {
    tcp::socket& socket_;
    mutable_buffer buffer_;
    enum { starting, reading, writing } state_;

    template <typename Self>
    void operator()(Self& self,
        error_code error,
        std::size_t n)
    {
      switch (state_)
      {
        // ...
      }
    }
  };

  template <typename CompletionToken>
  auto async_echo(tcp::socket& socket,
      mutable_buffer buffer,
      CompletionToken&& token)
  {
    return async_initiate<CompletionToken,
      void(error_code, std::size_t)>(
        composed(
          async_echo_implementation{socket, buffer,
            async_echo_implementation::starting}, socket),
        token, error_code{}, 0);
  }
  ``
  The `async_compose` function has been changed to be a thin wrapper around
  `composed`. However, unlike `async_compose`, `composed` allows arguments to be
  passed to the stateful implementation when the operation is initiated.
* Changed the `detached` completion token to work with asynchronous operations
  that have multiple completion signatures.
* Changed `async_initiate` to allow an empty variadic list of completion
  signatures, which would indicate that an asynchronous operation never
  completes.
* Added overloads of `async_initiate` that automatically deduce the type of
  the completion token. For example:[br]
  ``
  async_initiate(co_composed(/* ... */), detached, arg_1, arg_2);
  ``
  will deduce the token type from the argument `detached`.
* Added `async_immediate` which implements a trivial asynchronous operation that
  completes immediately, using an associated immediate executor if available.
  It is intended for use within asynchronous compositions to make it easier to
  provide optimised immediate completion.
* Updated the documentation for various asynchronous operations to specify
  immediate completion in terms of `async_immediate`.
* Enabled SFINAE-based partial specialisation of the `associator` trait.
* Changed to use the recycling allocator as the fallback for all operations,
  rather than calling the underlying recycling allocation helper functions
  directly.
* Fixed the `deferred` implementation to ensure that the wrapped initiation
  function object's copyability is correctly propagated.
* Fixed `experimental::coro` compatibility with clang 15.
* Fixed deduction of a completion handler's default immediate executor type.
* Don't use `ioctl` to modify the non-blocking mode on socket or descriptors
  that have been assigned, as they may originate from an external source.
* Don't call `fcntl` with `F_SETFL` if the flags aren't changing.
* Don't enable non-blocking mode when performing an `async_wait` operation on
  sockets or descriptors.
* Update some composed operation examples to destroy the timer object before
  calling the completion handler.
* Fix `read_until` regex support when `BOOST_ASIO_NO_DYNAMIC_BUFFER_V1` is
  defined.

[heading Asio 1.30.2 / Boost 1.85]

* Fixed `co_spawn` to correctly propagate exceptions resulting from cancellation
  to the completion handler.
* Added calls to `std::launder` to fix undefined behaviour in `awaitable<>`
  internal storage.
* Added missing handling of the `file_base::append` flag in the Windows
  implementation of file support.
* Updated the socket and descriptor implementations to add more cases where they
  will fall back to `fcntl` if a call to `ioctl` fails.
* Fixed a compile error that occurred when channels and `experimental::coro`
  were both used in the same translation unit.
* Added missing CancellationSlot type requirements to documentation.
* Minor documentation updates.

[heading Asio 1.30.1]

* Fixed the `async_result` primary template's concept checking to correctly
  handle lvalue-qualified completion signatures.
* Fixed some compile errors that could arise when using the `bind_allocator`,
  `bind_executor`, `bind_immediate_executor` and `bind_cancellation_slot`
  completion token adapters to adapt each other.
* Changed the `experimental::ranged_parallel_group` operation so that it moves
  the `completion_order` vector when invoking the completion handler.
* Fixed the [^boost/asio/experimental/parallel_group.hpp] header so that it is
  self-contained.
* Fixed some warnings about deprecated implicit copy constructors on
  `ip::basic_resolver_query`, `io_context::strand`, and `coroutine`.
* Updated the version specification used to initialise Winsock.
* Fixed the documentation hyperlinks for the deduced return types of
  asynchronous operations' initiating functions.

[heading Asio 1.30.0 / Boost 1.84]

* Fixed compatibility between `any_completion_handler` and compilation using
  `BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT`.
* Fixed a crash that may occur when attempting to access a default-constructed
  `any_completion_handler` object's associators.
* Fixed `ssl::stream<>` class's `async_handshake` operation so that it works
  with a defaulted completion token.
* Updated all examples to use C++11 as the minimum language standard.

[heading Asio 1.29.0]

* Changed to require C++11 as the minimum language standard.
* Removed deprecated functionality from the `boost::asio::execution` namespace.
* Removed deprecated invocation and allocation hooks.
* Added compatibility between Asio's placeholders and `std::bind`.
* Added `try_send_via_dispatch` and `try_send_n_via_dispatch` functions to
  channels.
* Improved C++11 support for multi-signature channels.
* Fixed compatibility between channel asynchronous operations and
  `any_completion_handler`.
* Added missing equality operators for mixed property types belonging to the
  same category.
* Fixed an issue where `spawn`-based stackful coroutines would terminate the
  program when used with asynchronous operations that have a completion
  signature starting with `std::exception_ptr`.

[heading Asio 1.28.2 / Boost 1.83]

* Fixed the completion token adapters `bind_allocator`, `bind_cancellation_slot`
  and `bind_immediate_executor` to not require a `return_type` type alias in
  the adapted `async_result` specialisation.
* Fixed a potental crash due to an object lifetime issue in the `co_spawn`
  operation's cancellation support.
* Enabled compiler-supported thread locals on more target platforms, using the
  `thread_local` keyword if available.
* Fixed the documentation of the per-operation cancellation behaviour for
  `experimental::co_composed` to correctly state that terminal cancellation is
  enabled by default.
* Documented the per-operation cancellation behaviour of `async_compose`.
* Added `bind_immediate_executor` to the `Completion Token Adapters` overview.
* Added an example illustrating how to use an `experimental channel` for
  mutual exclusion between cooperating asynchronous actors.
* Added an example showing how to write a minimal completion executor.

[heading Asio 1.28.1]

* Added missing compatibility with `associated_immediate_executor` to
  `any_completion_handler`.
* Fixed a null pointer dereference that occurs when using `query`, `require` or
  `prefer` with an empty `any_executor`.
* Added a workaround in `experimental::coro` for a spurious syntax error when
  compiling with MSVC.
* Fixed an integer truncation issue in per-operation cancellation, when using
  the reactor backend on 64-bit Windows.
* Added a compile-time check for a minimum Linux kernel version of 5.10, when
  [^io_uring] support is enabled.
* Fixed a compile error in the converting move constructors for
  `experimental::basic_channel` and `experimental::basic_concurrent_channel`.
* Fixed a memory leak on some `signal_set` error handling code paths.
* Fixed `bad_address_cast` to not use a deprecated implicit copy constructor.
* Fixed a copy/paste error in the `dev_poll_reactor` backend.
* Fixed the [^io_uring] backend to ensure the internal timeout operations, used
  to implement `io_context::run_for` and `io_context::run_until`, are
  cleaned up correctly.
* Eliminated some duplicated state in the `co_spawn` implementation's entry
  point, reducing memory consumption.
* Added missing c++14 echo examples.

[heading Asio 1.28.0 / Boost 1.82]

* Added missing handler tracking source location support to `awaitable<>`-based
  coroutine's ability to `co_await` asynchronous operations packaged as function
  objects.
* Add missing handler tracking source location support to `co_composed`.
* Fixed suppression of spurious 'potential null dereference' warnings, to work
  with older compilers.
* Fixed a bug where passing the deprecated `const_buffers_1` and
  `mutable_buffers_1` types to `asio::buffer()` would result in the contiguous
  iterator overloads being incorrectly chosen.
* Disabled the runtime Windows version test unless targeting older Windows
  versions.
* Fixed compatibility between buffered stream wrappers and move-constructible
  streams, such as `ssl::stream<>`.
* Marked `ip::address_v4::to_ulong` as deprecated in the documentation.
* Fixed shadowed variable warnings.
* Fixed `basic_socket_acceptor::async_accept` concept requirement checking to
  be compatible with lambdas that have a deduced return type.
* Fixed a feature detection macro used in `use_future`'s compatibility traits.
* Fixed `as_tuple` compatibility with legacy completion tokens.
* Fixed `redirect_error` compatibility with new completion tokens.
* Fixed a potential, Windows-specific program termination due to exceptions that
  should have been allowed to escape from a destructor.
* Fixed `this_coro` to prevent inadvertent `co_await` of boolean expressions.
* Fixed result handling in `experimental::use_coro` implementation.
* Fixed variadic template emulation for `is_async_operation` and
  `completion_signature_of`.
* Fixed incorrect reuse of a moved-from result in `experimental::promise`.
* Fixed `experimental::coro` use with custom allocators.
* Fixed clean up of internal I/O object structures when using [^io_uring].
* Use cached offset when seeking a file with seek_cur on Windows.
* Added immediate completion to asynchronous operation requirements.
* Added `any_completion_handler<>`, `co_composed`, and immediate completion
  support to the documentation overview.
* Added buffer literals to the documentation.
* Added a link to the
  [@https://github.com/chriskohlhoff/asio-debugger-extensions Asio debugger
  extensions] repository.

[heading Asio 1.27.0]

* Added the ability to customise the execution of a completion handler when an
  operation completes immediately. This change adds the
  `associated_immediate_executor` associator trait, `bind_immediate_executor`
  function, and `immediate_executor_binder` adapter. When a supported operation
  completes immediately (that is, within the initiating function) the
  associated immmediate executor is obtained, and the completion handler is
  delivered through that executor as if by using `asio::dispatch` on that
  executor. By default, the immediate executor delivers the completion handler
  as if using `asio::post` via the operation's I/O executor. For example, to
  allow a recursive call to the completion handler of an `async_read_some`
  operation, we may specify that immediate completion is delivered via a
  `system_executor`:[br]
  ``
  my_socket.async_read_some(my_buffer,
      bind_immediate_executor(
        system_executor(),
        [](error_code e, size_t n)
        {
          // ...
        }
      )
    );
  ``[br]
  Immediate execution is currently supported for asynchronous operations on
  reactor-based sockets and descriptors, and for asynchronous operations on
  channels.
* Added user-defined literals for buffer types. The `_buf` literal suffix,
  defined in namespace `asio::buffer_literals`, may be used to create
  const_buffer objects from string, binary integer, and hexadecimal integer
  literals. These buffer literals may be arbitrarily long. For example:[br]
  [pre
  using namespace asio::buffer_literals;

  asio::const_buffer b1 = "hello"_buf;
  asio::const_buffer b2 = 0xdeadbeef_buf;
  asio::const_buffer b3 = 0x0123456789abcdef0123456789abcdef_buf;
  asio::const_buffer b4 = 0b1010101011001100_buf;
  ][br]
  The memory associated with a buffer literal is valid for the lifetime of the
  program. This means that the buffer can be safely used with asynchronous
  operations:[br]
  ``
  async_write(my_socket, "hello"_buf, my_handler);
  ``[br]
* Added a new protocol type `local::seq_packet_protocol` to represent `AF_UNIX`
  with `SOCK_SEQPACKET`.
* Exposed `sigaction()` flags via optional argument to `signal_set::add`. When
  registering a signal, it is now possible to pass flags that specify the
  behaviour associated with the signal. These flags are specified as an enum
  type in a new class, signal_set_base, and are passed to the underlying
  `sigaction()` call. For example:[br]
  ``
  asio::signal_set sigs(my_io_context);
  sigs.add(SIGINT, asio::signal_set::flags::restart);
  ``[br]
  Specifying flags other than `flags::dont_care` will fail unless `sigaction()`
  is supported by the target operating system. Since signal registration is
  global, conflicting flags (multiple registrations that pass differing flags
  other than `flags::dont_care`) will also result in an error.
* Change `allocator_binder`, `executor_binder`, and `cancellation_slot_binder`
  to support detection of unspecialised associators.
* Fixed ambiguity in `associated_cancellation_slot<reference_wrapper>::get()`.
* Fixed `awaitable` handling for completion signatures containing
  `std::exception_ptr`.
* Fixed `experimental::channel` `try_send` failure after a `cancel`.
* Fixed `thread_pool::join()` deadlock when the pool has no internal threads.
* Fixed pipe `release()` when using [^io_uring].
* Fixed a data initialisation issue in the [^io_uring] backend.
* Fixed a dangling reference issue in the execution context overload of
  `get_associated_executor`.
* Ensured buffered messages can still be received when an
  `experimental::channel` is closed.
* Fixed the `any_completion_handler` assignment operator to work correctly.
* Constrained the constructor of the move-only class template
  `any_completion_handler` to prevent accidental copying
* Suppressed spurious 'potential null dereference' warnings.
* Changed to use `uint64_t` for OpenSSL options, to match OpenSSL 3.
* Fixed `deferred` interoperability with multiple completion signatures.
* Fixed channels to support C++14, and to partially support C++11. C++11
  support is limited to channels with a single completion signature, or
  channels with a void() signature (plus the error signature added by the
  channel traits).
* Added `any_completion_handler` to the documentation.

[heading Asio 1.26.0 / Boost 1.81]

* Fixed `spawn` and `co_spawn` implementations to dispatch cancellation
  handlers on the correct executor. When a completion handler uses a specified
  (i.e. non-default) associated executor, cancellation handlers are dispatched
  to the executor that was passed to `spawn()` or `co_spawn()`.
* Fixed `spawn` to ensure the completion handler is dispatched through the
  correct executor.
* Changed to use `snprintf` rather than `sprintf` on latest Xcode, to address
  deprecation warnings.
* Fixed compatibility between `co_spawn` and `any_completion_handler`.
* Fixed the arguments passed to `select_reactor::run` when it is run on an
  internal thread.
* Fixed compilation errors when `BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING` is
  defined.
* Updated detection of C++20 coroutine support on clang 14 and later.
  This includes the ability to use coroutines with libstdc++.
* Changed standard library feature detection to always enable
  `std::invoke_result` when targeting C++17 or later.
* Fixed detection of return type deduction with MSVC.
* Added a missing include in `experimental::coro` implementation.
* Updated the asynchronous operation requirements to relax the requirements on
  the associated executor.
* Added [^io_uring] to the implementation notes.

[heading Asio 1.25.0]

* Added the `consign` completion token adapter, which can be used to attach
  additional values to a completion handler. This is typically used to keep at
  least one copy of an object, such as a smart pointer, alive until the
  completion handler is called. For example:[br]
  ``
  auto timer1 = std::make_shared<asio::steady_timer>(my_io_context);
  timer1->expires_after(std::chrono::seconds(1));
  timer1->async_wait(
      asio::consign(
        [](boost::system::error_code ec)
        {
          // ...
        },
        timer1
      )
    );
  ``[br]
* Added `any_completion_handler<>`, which can be used to type-erase completion
  handlers. A typical use case is to enable separate compilation of
  asynchronous operation implementations. For example:[br]
  ``
  // Header file:

  void async_sleep_impl(
      asio::any_completion_handler<void(boost::system::error_code)> handler,
      asio::any_io_executor ex, std::chrono::nanoseconds duration);

  template <typename CompletionToken>
  inline auto async_sleep(asio::any_io_executor ex,
      std::chrono::nanoseconds duration, CompletionToken&& token)
  {
    return asio::async_initiate<
      CompletionToken, void(boost::system::error_code)>(
        async_sleep_impl, token, std::move(ex), duration);
  }

  // Separately compiled source file:

  void async_sleep_impl(
      asio::any_completion_handler<void(boost::system::error_code)> handler,
      asio::any_io_executor ex, std::chrono::nanoseconds duration)
  {
    auto timer = std::make_shared<asio::steady_timer>(ex, duration);
    timer->async_wait(asio::consign(std::move(handler), timer));
  }
  ``[br]
* Added `experimental::co_composed` which facilitates a lightweight
  implementation of user-defined asynchronous operations using C++20
  coroutines. The following example illustrates a simple asynchronous operation
  that implements an echo protocol in terms of a coroutine:[br]
  ``
  template <typename CompletionToken>
  auto async_echo(tcp::socket& socket,
      CompletionToken&& token)
  {
    return asio::async_initiate<
      CompletionToken, void(boost::system::error_code)>(
        asio::experimental::co_composed<
          void(boost::system::error_code)>(
            [](auto state, tcp::socket& socket) -> void
            {
              try
              {
                state.throw_if_cancelled(true);
                state.reset_cancellation_state(
                  asio::enable_terminal_cancellation());

                for (;;)
                {
                  char data[1024];
                  std::size_t n = co_await socket.async_read_some(
                      asio::buffer(data), asio::deferred);

                  co_await asio::async_write(socket,
                      asio::buffer(data, n), asio::deferred);
                }
              }
              catch (const boost::system::system_error& e)
              {
                co_return {e.code()};
              }
            }, socket),
        token, std::ref(socket));
  }
  ``[br]
* Add range-based experimental::make_parallel_group() overloads that may be used
  to launch a dynamically-sized set of asynchronous operations, where all
  operations are the same type. For example:[br]
  ``
  using op_type = decltype(
      socket1.async_read_some(
        asio::buffer(data1),
        asio::deferred
      )
    );

  std::vector<op_type> ops;
  ops.push_back(
      socket1.async_read_some(
        asio::buffer(data1),
        asio::deferred
      )
    );
  ops.push_back(
      socket2.async_read_some(
        asio::buffer(data2),
        asio::deferred
      )
    );

  asio::experimental::make_parallel_group(ops).async_wait(
      asio::experimental::wait_for_all(),
      [](
          std::vector<std::size_t> completion_order,
          std::vector<boost::system::error_code> e,
          std::vector<std::size_t> n
        )
      {
        for (std::size_t i = 0; i < completion_order.size(); ++i)
        {
          std::size_t idx = completion_order[i];
          std::cout << "socket " << idx << " finished: ";
          std::cout << e[idx] << ", " << n[idx] << "\n";
        }
      }
    );
  ``[br]
  Thanks go to Klemens Morgenstern for supplying part of this implementation.
* Added `any_completion_executor`, a type-erased wrappers for executors that
  are associated with completion handlers.
* Added missing `context` query to use_future's executor.
* Added nothrow constructor overloads to `execution::any_executor<>` and
  `any_io_executor`.
* Optimised representation of empty `execution::any_executor` objects to improve
  the performance of copy and move operations.
* Added an `associated_cancellation_slot` specialisation for
  `std::reference_wrapper`.
* Changed I/O objects to return their executors by const reference.
* Changed associated to use deduced return types for all two-argument `get`
  functions.
* Fixed `spawn` implementation to catch unhandled exceptions and rethrow them
  outside of the spawned "thread".
* Fixed cleanup of of terminal-state `spawn` "thread" objects.
* Changed semantics of 'dispatch' to mean the executor is used as-is. An
  execution context's default executor is imbued with the possibly-blocking
  property.
* Deprecated the `execution::execute` customisation point. Use `execute` as a
  member function.
* Deprecated the concepts, traits, functions and customisation points related to
  senders and receivers.
* Added a C++11 `parallel_group` example.
* Fixed example code to not use the deprecated conversion of a resolve result to
  an endpoint.
* Fixed an ambiguity in `experimental::channel_traits` specialisations.
* Added a specialised channel implementation for the  for `R(error_code)`
  signature.
* Made `cancelled()` public on the `async_compose` 'self' object.
* Added io_executor_type and get_io_executor to the `async_compose` 'self'
  object.
* Fixed implementation of `release()` for Windows overlapped handles.
* Enabled deferred awaiting for `experimental::coro`, regularised
  `experimental::use_coro`, and fixed allocator handling. This means that
  `use_coro` does not return a coro object, just like use_awaitable does, i.e.
  it's an overhead that buys us type erasure. Allocators can now be set for
  `coro` by including `allocator_arg` in the coro signature.
* Cleaned up `experimental::promise` and made it an asynchronous operation
  object.
* Constrained `post`/`defer` overloads on ability to require `blocking.never`.
* Changed descriptor implementation to fall back to `fcntl` if `ioctl` fails
  with `ENOTTY` when setting non-blocking mode.

[heading Asio 1.24.0 / Boost 1.80]

* Added a deduced trailing return type, using `decltype`, to all asynchronous
  operations' initiating functions when using C++11. This change enables the
  new form of `async_result`, where the return type can vary per operation,
  for C++11.
* Moved `append`, `prepend`, `as_tuple`, and `deferred` to the `boost::asio`
  namespace, and made them compatible with C++11. These are no longer
  experimental facilities, although the names have temporarily been retained
  under the `boost::asio::experimental` namespace for backwards compatibility.
* Added `buffer()` overloads for contiguous containers, such as `std::span`.
* Added the ability for `awaitable<>`-based coroutines to directly `co_await`
  operations that are packaged as function objects. For example, using
  `deferred`:[br]
  ``
  asio::awaitable<void> my_coro()
  {
    asio::steady_timer timer(co_await asio::this_coro::executor);
    timer.expires_after(std::chrono::seconds(5));

    co_await timer.async_wait(asio::deferred);
  }
  ``
  or with a handcrafted function object:[br]
  ``
  asio::awaitable<void> my_coro()
  {
    asio::steady_timer timer(co_await asio::this_coro::executor);
    timer.expires_after(std::chrono::seconds(5));

    co_await [&](auto&& token)
    {
      return timer.async_wait(std::forward<decltype(token)>(token));
    };
  }
  ``[br]
* Changed `spawn()` to be a completion token-based asynchronous operation. This
  introduces new `spawn()` overloads that conform to the requirements for
  asynchronous operations. For example:[br]
  ``
  std::string do_read(asio::yield_context yield)
  {
    char data[1024];
    size_t n = my_socket.async_read_some(asio::buffer(data), yield);
    return std::string(data, n);
  }

  asio::spawn(my_executor, do_read,
      [](std::exception_ptr ex, std::string result)
      {
        // ...
      });
  ``
  These new `spawn()` overloads support cancellation, and the
  `basic_yield_context` completion token has also been enhanced to support
  move-only and variadic result types. When targeting C++11 and later, these
  functions are implemented in terms of Boost.Context directly. The existing
  overloads have been retained but are deprecated.
* Added the `is_async_operation` trait and `async_operation` concept. The
  `is_async_operation` trait may be used to determine if a function object, and
  optional arguments, may be called to initiate an asynchronous operation. For
  example, when using `deferred`:[br]
  ``
  auto d = my_timer.async_wait(asio::deferred);
  static_assert(asio::is_async_operation<decltype(d)>::value);
  ``[br]
  or with a handcrafted asynchronous operation:[br]
  ``
  struct my_async_op
  {
    asio::ip::tcp::socket& socket_ = ...;

    template <typename Token>
    auto operator()(asio::const_buffer data, Token&& token)
    {
      return asio::async_write(socket_, data,
          std::forward<Token>(token));
    }
  };

  static_assert(
      asio::is_async_operation<
        my_async_op, asio::const_buffer>::value);
  ``[br]
* Added the `completion_signature_of` trait. The `completion_signature_of`
  trait (and corresponding type alias `completion_signature_of_t`) may be used
  to determine the completion signature of an asynchronous operation. For
  example:[br]
  ``
  auto d = my_timer.async_wait(asio::deferred);
  using sig = asio::completion_signature_of<decltype(d)>::type;
  // sig is void(error_code)
  ``[br]
  or with a handcrafted asynchronous operation:[br]
  ``
  struct my_async_op
  {
    asio::ip::tcp::socket& socket_ = ...;

    template <typename Token>
    auto operator()(asio::const_buffer data, Token&& token)
    {
      return asio::async_write(socket_, data,
          std::forward<Token>(token));
    }
  };

  using sig =
    asio::completion_signature_of<
      my_async_op, asio::const_buffer>::type;
  // sig is void(error_code, size_t)
  ``[br]
* Added converting move construction/assignment to posix descriptors, serial
  ports, pipes, Windows `object_handle`, Windows stream handles, and Windows
  random-access handles.
* Added `release()` member functions to pipes, Windows stream handles, and
  Windows random-access handles.
* Enabled support for `Endpoint` implementations that return `void` pointers
  from their `data()` member functions, as per the documented `Endpoint` type
  requirements.
* Removed `all()` and `race()` from `experimental::promise`, as
  `experimental::parallel_group` covers this functionality.
* Added source locations to exceptions and error codes produced by the
  synchronous and asynchronous operations.
* Fixed compatibility with OpenSSL 3.0.4 and later.
* Fixed compatibility with with [^-masm=intel].
* Explicitly stated that socket `shutdown()` calls are thread-safe with respect
  to certain other synchronous operations on the same socket.
* Optimised the move construction of I/O objects where only the executor type
  differs.
* Fixed the detection of `std::invoke_result` for clang/libc++.
* Fixed an issue where `experimental::parallel_group` initiation incorrectly
  moved arguments instead of forwarding them.
* Fixed a sequencing issue in the implementation of `post()`, `dispatch()`,
  and `defer()`, where the the associated allocator may be obtained from an
  already moved-from completion handler.
* Fixed the `awaitable<>` implementation to propagate exceptions from awaited
  initiation functions through the current completion handler.
* Fixed detection of `std::aligned_alloc` with [^gcc] 7.
* Changed to avoid using the soon-to-be-deprecated `std::aligned_storage` on
  newer compilers.
* Fixed detection of `std::aligned_alloc` for older Apple platforms.
* Removed faulty assertions from `experimental::coro` implementation.
* Added defence against Qt-defined macros when building with Intel C++.
* Changed the implementation of the `select_reactor`, on Windows, to ensure that
  any exception resulting from failure to recreate its interrupter's sockets
  will be allowed to propagate out through `io_context::run()`.
* Fixed various compiler warnings.
* Updated all composed operations examples, and the C++11 timeouts example, to
  use the new `async_result` form.
* Added composed operation and coroutine examples for C++20.

[heading Asio 1.22.2 / Boost 1.79]

* On Windows, changed the file support to open files using the same sharing mode
  as `fopen()`.
* On Linux, fixed the UNIX domain sockets implementation to correctly handle
  `EAGAIN` as an indication of an in-progress connect operation.
* Fixed `experimental::basic_channel::reset()` and
  `experimental::basic_concurrent_channel::reset()` so that they work correctly
  for an unclosed channel.
* Fixed potential undefined behaviour in the `experimental::promise` operations
  `race()` and `all()`.
* Changed the `co_spawn` implementation to explicitly dispatch cancellation
  signals through the specified executor, if the the completion handler has an
  associated executor of its own.
* Added more detailed reference documentation to `make_strand()`,
  `make_work_guard()`, `ip::address_v4`, `ip::address_v6`,
  `experimental::basic_channel`, and `experimental::basic_concurrent_channel`.
* Re-arranged and extended the Overview documentation to cover files, pipes,
  `async_compose`, `experimental::deferred`, `experimental::parallel_group`,
  `experimental::promise`, channels, and completion token adapters.
* Reverted the `io_context` reference documentation to use `executor_work_guard`
  when preventing the `io_context` from running out of work.
* Removed references to `deadline_timer` from the Overview documentation.
* Added reference documentation cross-references to asynchronous model elements.

[heading Asio 1.22.1]

* Added `bind_allocator`, to simplify associating a custom allocator with a
  completion token or handler.
* Added the `file_base::sync_all_on_write` flag, which maps to `O_SYNC` on POSIX
  and `FILE_FLAG_WRITE_THROUGH` on Windows.
* Added missing implementation of `basic_file::release()`.
* Added per-operation cancellation support to signal sets.
* Exposed `recycling_allocator` as part of the public interface.
* Added the `nodiscard` attribute to the following functions:
  * `bind_allocator()`
  * `bind_cancellation_slot()`
  * `bind_executor()`
  * `buffer()`
  * `dynamic_buffer()`
  * `experimental::append()`
  * `experimental::as_single()`
  * `experimental::as_tuple()`
  * `experimental::make_parallel_group()`
  * `experimental::prepend()`
  * `get_associated_allocator()`
  * `get_associated_cancellation_slot()`
  * `get_associated_executor()`
  * `make_work_guard()`
* Added compatibility with OpenSSL 3.0, particularly when deprecated
  functionality is disabled.
* Added support for adopting an existing `SSL*` into an `ssl::stream<>`.
* Enabled `executor_work_guard<>` even when `BOOST_ASIO_NO_TS_EXECUTORS` is
  defined.
* Enabled movable socket iostreams when using clang.
* Fixed `bind_cancellation_slot` compatibility with legacy completion tokens.
* Fixed `bind_executor` compatibility with legacy completion tokens.
* Fixed `associator` specialisations for `experimental::append` and
  `experimental::prepend`, to correctly propagate the associated allocator,
  executor, and cancellation slot.
* Fixed 'zero as null pointer constant' warning in C++20 coroutines
  implementation of `awaitable`.
* Ensured concurrency hint preprocessor macros are made available when
  [^asio/io_context.hpp] is included.
* Fixed issue where the primary `associated_allocator` template was not
  correctly detecting the nested `T::allocator_type`.
* Fixed [^io_uring] implementation of `async_receive_from` operation for
  sockets.
* Fixed [^io_uring] implementation of `write_some_at` operation for files.
* Changed [^io_uring] implementation to correctly check that it is not the
  default before registering with reactor.
* Fixed a circular inclusion issue when using [^io_uring] in some build
  configurations.
* Fixed `experimental::coro`'s per-operation cancellation to clear the slot at
  completion of each operation.
* Fixed memory management in `experimental::promise`'s type-erased completion
  handlers.
* Fixed move `operator=` implementation for `ssl::stream`.
* Fixed `any_io_executor` implementation to work when both
  `BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT` and `BOOST_ASIO_SEPARATE_COMPILATION`
  are defined.
* Fixed implementation of `basic_socket::at_mark()` when using the
  `sockatmark()` system call.
* Changed the recycling allocator to use the default alignment as the minimum
  alignment for allocations.
* Added additional standard header file includes, as required by newer
  compilers.
* Added a workaround for apparent coroutine codegen bug with Apple's clang.
* Fixed various warnings in the examples and unit tests.
* Added a C++11 example showing file descriptor passing over local sockets.
  Thanks to Heiko Hund for providing this example.
* Added C++14 examples of wrapping callback-based APIs in asynchronous
  operations.
* Added an overview of Asio's asynchronous model to the documentation.
* Reworked reference documentation in terms of completion tokens.
* Updated documentation of asynchronous operation requirements to use new
  completion token form.
* Updated documentation for `dispatch()`, `post()`, and `defer()` to cover both
  the old and new executor forms.
* Documented per-operation cancellation for serial ports.
* Clarified the non-concurrency guarantees made for allocators.

[heading Asio 1.22.0 / Boost 1.78]

* Added an io_uring backend. This backend may be used for all I/O objects,
  including sockets, timers, and posix descriptors.[br]
  [br]
  The backend is disabled by default, and must be enabled by defining both
  `BOOST_ASIO_HAS_IO_URING` and `BOOST_ASIO_DISABLE_EPOLL`.[br]
  [br]
  Simply defining `BOOST_ASIO_HAS_IO_URING` alone will enable the backend
  without using it for the existing I/O objects. This allows it to be used for
  I/O objects that require io_uring support, such as files.[br]
  [br]
  This support depends on the [^liburing] library at both compile and link
  time. Add `-luring` to your list of libraries for linking.
* Added support for files. This introduces new classes for stream-oriented and
  random-access files. For example, to write to a newly created stream-oriented
  file:[br]
  ``
  asio::stream_file file(
      my_io_context, "/path/to/file",
      asio::stream_file::write_only
        | asio::stream_file::create
        | asio::stream_file::truncate);

  file.async_write_some(my_buffer,
      [](error_code e, size_t n)
      {
        // ...
      });
  ``[br]
  or to read from a random-access file:[br]
  ``
  asio::random_access_file file(
      my_io_context, "/path/to/file",
      asio::random_access_file::read_only);

  file.async_read_some_at(1234, my_buffer,
      [](error_code e, size_t n)
      {
        // ...
      });
  ``[br]
  This feature currently supports I/O completion ports on Windows, and io_uring
  on Linux (define `BOOST_ASIO_HAS_IO_URING` to enable).
* Added support for portable pipes. This change add supports for pipes on POSIX
  and Windows (when I/O completion ports are available). For example, to create
  and use a connected pair of pipe objects:[br]
  ``
  asio::readable_pipe read_end;
  asio::writable_pipe write_end;
  asio::connect_pipe(read_end, write_end);

  write_end.async_write_some(my_write_buffer,
      [](error_code e, size_t n)
      {
        // ...
      });

  read_end.async_read_some(my_read_buffer,
      [](error_code e, size_t n)
      {
        // ...
      });
  ``[br]
* Added support for registered buffers. The `mutable_registered_buffer` and
  `const_registered_buffer` classes are buffer sequence types that represent
  registered buffers. These buffers are obtained by first performing a buffer
  registration:[br]
  ``
    auto my_registration =
      asio::register_buffers(
          my_execution_context,
          my_buffer_sequence);
  ``[br]
  The registration object must be maintained for as long as the buffer
  registration is required. The supplied buffer sequence represents the
  memory location or locations that will be registered, and the caller
  must ensure they remain valid for as long as they are registered. The
  registration is automatically removed when the registration object is
  destroyed. There can be at most one active registration per execution
  context.[br]
  [br]
  The registration object is a container of registered buffers. Buffers
  may be obtained from it by iterating over the container, or via direct
  index access:[br]
  ``
    asio::mutable_registered_buffer my_buffer
      = my_registration[i];
  ``[br]
  The registered buffers may then be passed directly to operations:[br]
  ``
  asio::async_read(my_socket, my_buffer,
      [](error_code ec, size_t n)
      {
        // ...
      });
  ``[br]
  Buffer registration supports the io_uring backend when used with read and
  write operations on descriptors, files, pipes, and sockets. For portability,
  the facility may be used on other platforms, but the registered buffers will
  behave as normal buffers.
* Added experimental support for channels. This adds templates
  `experimental::basic_channel` and `experimental::basic_concurrent_channel`,
  with aliases `experimental::channel` and `experimental::concurrent_channel`.
  Channels may be used to send completions as messages. For example:[br]
  ``
  // Create a channel with no buffer space.
  channel<void(error_code, size_t)> ch(ctx);

  // The call to try_send fails as there is no buffer
  // space and no waiting receive operations.
  bool ok = ch.try_send(asio::error::eof, 123);
  assert(!ok);

  // The async_send operation is outstanding until
  // a receive operation consumes the message.
  ch.async_send(asio::error::eof, 123,
      [](error_code ec)
      {
        // ...
      });

  // The async_receive consumes the message. Both the
  // async_send and async_receive operations complete
  // immediately.
  ch.async_receive(
      [](error_code ec, size_t n)
      {
        // ...
      });
  ``[br]
* Implemented improvements to `experimental::coro`.
  * Added overload so member functions can provide an explicit executor.
  * Added `co_spawn` for `coro` tasks.
  * Added reference and overview documentation.
  * Adopted awaitable cancellation model.
  * Refactored implementation.
* Disabled `aligned_alloc` on [^clang] when using an MSVC runtime.
* Changed to use a faster implementation for `ip::network_v4::canonical()`.
* Added template specialisations for common uses to improve compile time.
* Reduced the size of `io_context` executors to a single pointer.
* Increased the small object buffer size for `execution::any_executor` and
  `any_io_executor`.
* Fixed multi-signature handling when variadic templates are disabled.
* Fixed compatibility with new versions of [^gcc] and [^clang].
* Fixed compilation on Solaris.
* Fixed defence against Qt-defined macros when building with MSVC.
* Improved error messages emitted by `ssl` facilities.
* Fixed `bind_executor` compatibility with completion tokens.
* Fixed build errors when `BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT` is defined.
* Added missing move assignment operator to `awaitable<>`.
* Fixed an access violation when using coroutines with MSVC, due to incorrect
  alignment of allocated memory.
* Fixed a cleanup issue in `experimental::parallel_group` that occured when the
  execution context was shut down with parallel operations still pending.
* Added clarifications to the documentation on concurrency hints.
* Added documentation on error handling techniques for C++20 coroutines.
* Fixed various warnings.

[heading Asio 1.20.0 / Boost 1.77]

* Added support for cancellation of individual asynchronous operations.
  Cancellation is implemented by having each completion handler carry an
  associated `CancellationSlot`, a lightweight cancellation channel that is
  specified through the new `associated_cancellation_slot` associator. A
  concrete `CancellationSlot` implementation is provided in the form of the
  `cancellation_signal` and `cancellation_slot` classes. In conjunction with
  the `bind_cancellation_slot` helper function, these may be used to hook
  cancellation into asynchronous operations. However, it should be noted that
  these classes are the low-level building blocks of cancellation, and most use
  cases should use a higher level abstraction for cancellation, such as
  `experimental::parallel_group` or the new logical operators for `awaitable`
  (see below). The ability to cancel individual operations, or composed
  operations, is currently supported by:
  * timers
  * sockets on POSIX and Windows
  * POSIX descriptors
  * Windows HANDLEs
  * SSL streams
  * all Asio-provided composed operations such as `async_read` and `async_write`
  * compositions based on `async_compose`
  * C++20 coroutines that use `awaitable`
  * C++20 coroutines that use the new `experimental::coro` (see below)
  * the new `experimental::parallel_group` operation (see below)
  * the new `experimental::promise` class (see below)
* Added the `associator` trait. The `associator` trait is used to generically
  forward associators, such as `associated_executor` and `associated_allocator`,
  through intermediate completion handlers. For example:[br]
  ``
  template <typename Handler>
  struct intermediate_handler
  {
    Handler handler_;

    template <typename... Args>
    void operator()(Args&... args)
    {
      // ...
    }
  };

  namespace asio {
    template <
        template <typename, typename> class Associator,
        typename Handler,
        typename DefaultCandidate>
    struct associator<
        Associator,
        intermediate_handler<Handler>,
        DefaultCandidate>
    {
      using type =
        typename Associator<Handler, DefaultCandidate>::type;

      static type get(
          const intermediate_handler<Handler>& h,
          const DefaultCandidate& c = DefaultCandidate()) noexcept
      {
        return Associator<Handler, DefaultCandidate>::get(
            h.handler_, c);
      }
    };
  } // namespace asio
  ``[br]
* Changed all asynchronous operations implemented in Asio to invoke their
  completion handlers as rvalue references. This allows an rvalue reference
  qualifier to be added to the function call operator.
* Added support for asynchronous operations with multiple completion signatures.
  Completion signatures may also specify that they are `noexcept`, and whether
  they are lvalue-invocable (and thus do not "consume" the completion handler)
  or rvalue-invocable (and thus do "consume" the handler, indicating an end to
  the asynchronous operation). For example:[br]
  ``
  auto my_async_operation(...,
      asio::completion_token_for<
        void(intermediate_result_type) & noexcept,
        void(final_result_type) &&
      > auto&& token)
  {
    // ...
  }
  ``[br]
* Added `operator&&` and `operator||` for `awaitable<>`. The logical operators
  `||` and `&&` have been overloaded for `awaitable<>`, to allow coroutines to
  be trivially awaited in parallel.[br]
  [br]
  When awaited using `&&`, the `co_await` expression waits until both operations
  have completed successfully. As a "short-circuit" evaluation, if one
  operation fails with an exception, the other is immediately cancelled.
  For example:[br]
  ``
  std::tuple<std::size_t, std::size_t> results =
    co_await (
      async_read(socket, input_buffer, use_awaitable)
        && async_write(socket, output_buffer, use_awaitable)
    );
  ``[br]
  When awaited using `||`, the `co_await` expression waits until either
  operation succeeds. As a "short-circuit" evaluation, if one operation
  succeeds without throwing an exception, the other is immediately cancelled.
  For example:[br]
  ``
  std::variant<std::size_t, std::monostate> results =
    co_await (
      async_read(socket, input_buffer, use_awaitable)
        || timer.async_wait(use_awaitable)
    );
  ``[br]
  The operators may be enabled by adding the `#include`:[br]
  ``
  #include <boost/asio/experimental/awaitable_operators.hpp>
  ``[br]
  and then bringing the contents of the `experimental::awaitable_operators`
  namespace into scope:[br]
  ``
  using namespace asio::experimental::awaitable_operators;
  ``[br]
* Added the `experimental::as_tuple` completion token adapter. The `as_tuple`
  completion token adapter can be used to specify that the completion handler
  arguments should be combined into a single tuple argument. The `as_tuple`
  adapter may be used in conjunction with `use_awaitable` and structured
  bindings as follows:[br]
  ``
  auto [e, n] = co_await socket.async_read_some(
      asio::buffer(data), as_tuple(use_awaitable));
  ``[br]
  Alternatively, it may be used as a default completion token like so:[br]
  ``
  using default_token = as_tuple_t<use_awaitable_t<>>;
  using tcp_socket = default_token::as_default_on_t<tcp::socket>;
  // ...
  awaitable<void> do_read(tcp_socket socket)
  {
    // ...
    auto [e, n] = co_await socket.async_read_some(asio::buffer(data));
    // ...
  }
  ``[br]
* Added the `experimental::append` completion token adapter. The `append`
  completion token adapter can be used to pass additional completion handler
  arguments at the end of the completion signature. For example:[br]
  ``
  timer.async_wait(
      asio::experimental::append(
        [](boost::system::error_code ec, int i)
        {
          // ...
        },
      42)
    );

  std::future<int> f = timer.async_wait(
      asio::experimental::append(
        asio::use_future,
        42
      )
    );
  ``[br]
* Added the `experimental::prepend` completion token adapter. The `prepend`
  completion token adapter can be used to pass additional arguments before the
  existing completion handler arguments. For example:[br]
  ``
  timer.async_wait(
      asio::experimental::prepend(
        [](int i, boost::system::error_code ec)
        {
          // ...
        },
      42)
    );

  std::future<std::tuple<int, boost::system::error_code>> f = timer.async_wait(
      asio::experimental::prepend(
        asio::use_future,
        42
      )
    );
  ``[br]
* Added the `experimental::deferred` completion token. The `deferred`
  completion token takes a call to an asynchronous operation's initiating
  function and turns it into a function object that accepts a completion token.
  For example:[br]
  ``
  auto deferred_op =
    timer.async_wait(
      asio::experimental::deferred);
  ...
  std::move(deferred_op)(
      [](boost::system::error_code ec){ ... });
  ``[br]
  or:[br]
  ``
  auto deferred_op =
    timer.async_wait(
      asio::experimental::deferred);
  ...
  std::future<void> =
    std::move(deferred_op)(
      asio::use_future);
  ``[br]
  The deferred token also supports chaining, to create simple compositions:[br]
  ``
  auto deferred_op =
    timer.async_wait(
      asio::experimental::deferred(
        [&](boost::system::error_code ec)
        {
          timer.expires_after(
              std::chrono::seconds(1));

          return timer.async_wait(
              asio::experimental::deferred);
        });
  ...
  std::future<void> = std::move(deferred_op)(asio::use_future);
  ``[br]
* Added the `experimental::parallel_group` class and
  `experimental::make_parallel_group` function. This utility may be used to
  launch work that is performed in parallel, and wait for one or all of the
  operations to complete. A `parallel_group` implements automatic cancellation
  of incomplete operations. For example:[br]
  ``
  experimental::make_parallel_group(
      [&](auto token)
      {
        return stream.async_read_some(asio::buffer(data), token);
      },
      [&](auto token)
      {
        return timer.async_wait(token);
      }
    ).async_wait(
      experimental::wait_for_one(),
      [](
          std::array<std::size_t, 2> completion_order,
          boost::system::error_code ec1, std::size_t n1,
          boost::system::error_code ec2
      )
      {
        // ...
      }
    );
  ``[br]
  The conditions for completion of the group may be specified using one of the
  four provided function objects `wait_for_all`, `wait_for_one`,
  `wait_for_one_success`, and `wait_for_one_error`, or with a custom function.
  The `parallel_group` class can also be combined with `deferred` as
  follows:[br]
  ``
  experimental::make_parallel_group(
      stream.async_read_some(asio::buffer(data), experimental::deferred),
      timer.async_wait(experimental::deferred)
    ).async_wait(
      // ...
    );
  ``[br]
  Note: for maximum flexibility, `parallel_group` does not propagate the
  executor automatically to the operations within the group.
* Added `experimental::promise`. The `promise` type allows eager execution and
  synchronisation of async operations. For example:[br]
  ``
  auto promise = async_read(
      stream, asio::buffer(my_buffer),
      asio::experimental::use_promise);

  ... do other stuff while the read is going on ...

  promise.async_wait( // completion the operation
      [](error_code ec, std::size_t bytes_read)
      {
        ...
      });
  ``[br]
  Promises can be safely disregarded if the result is no longer required.
  Different operations can be combined to either wait for all to complete
  or for one to complete (and cancel the rest). For example, to wait for
  one to complete:[br]
  ``
  auto timeout_promise =
    timer.async_wait(
      asio::experimental::use_promise);

  auto read_promise = async_read(
      stream, asio::buffer(my_buffer),
      asio::experimental::use_promise);

  auto promise =
    asio::experimental::promise<>::race(
      timeout_promise, read_promise);

  promise.async_wait(
      [](std::variant<error_code, std::tuple<error_code, std::size_t>> v)
      {
        if (v.index() == 0) {} //timed out
        else if (v.index() == 1) // completed in time
      });
  ``[br]
  or to wait for all to complete:[br]
  ``
  auto write_promise = async_write(
      stream, asio::buffer(my_write_buffer),
      asio::experimental::use_promise);

  auto read_promise = async_read(
      stream, asio::buffer(my_buffer),
      asio::experimental::use_promise);

  auto promise =
    asio::experimental::promise<>::all(
      write_promise, read_promise);

  promise.async_wait(
      [](std::tuple<error_code, std::size_t> write_result,
        std::tuple<error_code, std::size_t> read_result)
      {
      });
  ``[br]
  Thanks go to Klemens Morgenstern for contributing this feature.
* Added the `experimental::coro` class template. The `coro` type is a C++20
  coroutine primitive for resumable functions, with the ability to combine both
  asynchronous waiting (`co_await`) and yielding (`co_yield`) into a single,
  stateful control flow. For example:[br]
  ``
  #include <boost/asio.hpp>
  #include <boost/asio/experimental/coro.hpp>

  using asio::ip::tcp;

  asio::experimental::coro<std::string> reader(tcp::socket& sock)
  {
    std::string buf;
    while (sock.is_open())
    {
      std::size_t n = co_await asio::async_read_until(
          sock, asio::dynamic_buffer(buf), '\n',
          asio::experimental::use_coro);
      co_yield buf.substr(0, n);
      buf.erase(0, n);
    }
  }

  asio::awaitable<void> consumer(tcp::socket sock)
  {
    auto r = reader(sock);
    auto msg1 = co_await r.async_resume(asio::use_awaitable);
    std::cout << "Message 1: " << msg1.value_or("\n");
    auto msg2 = co_await r.async_resume(asio::use_awaitable);
    std::cout << "Message 2: " << msg2.value_or("\n");
  }

  asio::awaitable<void> listen(tcp::acceptor& acceptor)
  {
    for (;;)
    {
      co_spawn(
          acceptor.get_executor(),
          consumer(co_await acceptor.async_accept(asio::use_awaitable)),
          asio::detached);
    }
  }

  int main()
  {
    asio::io_context ctx;
    tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
    co_spawn(ctx, listen(acceptor), asio::detached);
    ctx.run();
  }
  ``[br]
  Thanks go to Klemens Morgenstern for contributing this feature.
* Added move assignment to `ssl::stream<>`.
* Changed `co_spawn` to `dispatch` the coroutine's initial step to the executor,
  and to only `post` the completion handler if the coroutine did not otherwise
  perform a context switch (i.e. a `co_await` on an asynchronous operation).
* Enabled additional optimisations for `any_executor` and `any_io_executor`
  when used with asynchronous operations.
* Added the `nodiscard` attribute to `awaitable<>`.
* Increased the number of cached slots in the default recycling allocator.
  This number defaults to 2, but may also be specified by defining the
  `BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE` macro.
* Disabled the `std::system_error` message workaround for recent MSVC.
* Changed the default allocator behaviour to respect alignment requirements,
  to support over-aligned types. Requires C++17 or later, or Boost.
* Ensured the result strings are always initialised in reverse name resolution.
* Fixed recursive template instantiation issues in
  `use_awaitable_t::executor_with_default`.
* Fixed the `any_io_executor` equality operators to correctly return a result
  based on the target executor.
* Fixed `strand<>` to avoid using a potentially moved-from executor.
* Ensured [^gcc] tests are not used for [^clang] when detecting compiler
  features.
* Disabled coroutines support for the [^clang] shipped with MSVC.
* Fixed compatibility with recent LibreSSL when `OPENSSL_NO_SSL_INTERN` is
  defined.
* Fixed `posix::basic_stream_descriptor` move operations to work with
  non-defaulted executors.

[heading Asio 1.18.2 / Boost 1.76]

* Added `ip::scope_id_type` type alias.
* Added `ip::port_type` type alias.
* Added `std::hash` specialisations for IP addresses.
* Added `std::hash` specialisations for `ip::basic_endpoint<>`.
* Refactored SFINAE usage to improve compile times.
* Added friendship support to customisation points, and made most customisations private.
* Changed `any_io_executor` to a "strong typedef"-style class.
* Fixed `experimental::as_single` to work with handler hook deprecation.
* Ensured pthread condition variable attributes are cleaned up on all platforms.
* Clarified thread safety notes on sockets and descriptors.
* Ensured `errno` is not overwritten if `socket()` fails on macOS/FreeBSD.
* Fixed work tracking for `io_context` and `thread_pool` executors when move-assigned.
* Ensured internal `call_stack` objects are accessed only from implementation files.
* Fixed I/O object move-assignment to ensure the executor is left in a valid state.
* Fixed detection of compiler support for defaulted template argument on functions with MSVC.
* Prevented the `blocking.always` property from being used with `strand<>`, as it
  did not produce the correct semantics.
* Removed deprecated file [^asio/impl/src.cpp].

[heading Asio 1.18.1 / Boost 1.75]

* Enabled support for UNIX domain sockets on Windows. From Windows 10, UNIX
  domain sockets (a.k.a "local" sockets) are supported on Windows, with the
  exception of the `connect_pair` function (which will fail with an
  operation_not_supported error).
* Added executor-converting construction and assignment to `ip::basic_resolver`.
* Added compatibility between polymorphic executors and the (deprecated) handler
  invocation hook.
* Added the `experimental::as_single` completion token adapter. The `as_single`
  completion token adapter can be used to specify that the completion handler
  arguments should be combined into a single argument. For completion signatures
  with a single parameter, the argument is passed through as-is. For signatures
  with two or more parameters, the arguments are combined into a tuple. The
  `as_single` adapter may be used in conjunction with `use_awaitable` and
  structured bindings as follows:[br]
  ``
  auto [e, n] = co_await socket.async_read_some(
      boost::asio::buffer(data), as_single(use_awaitable));
  ``[br]
  Alternatively, it may be used as a default completion token like so:[br]
  ``
  using default_token = as_single_t<use_awaitable_t<>>;
  using tcp_socket = default_token::as_default_on_t<tcp::socket>;
  // ...
  awaitable<void> do_read(tcp_socket socket)
  {
    // ...
    auto [e, n] = co_await socket.async_read_some(boost::asio::buffer(data));
    // ...
  }
  ``[br]
* Added support for `MSG_NOSIGNAL` on more platforms by using  `_POSIX_VERSION`
  to detect whether it is supported.
* Added the ability to compile using libpthread on Windows.
* Added workarounds for the Intel C++ compiler.
* Added more support for detecting and optimising for handlers that have no
  custom executor.
* Reduced lock contention for timer cancellation on Windows.
* Reinstated a previously removed null-pointer check, as it had a measurable
  impact on performance.
* Fixed the `executor` concept to test for a const-qualified `execute()`.
* Fixed `any_executor` support for builds without RTTI support.
* Fixed the `thread_pool` unit test to work without RTTI support.
* Fixed C++20 coroutines compatibility with clang on Windows.
* Fixed some compatibility issues with Windows Runtime.
* Fixed shadow name warnings caused by addition of `asio::query`.
* Fixed a "logical ‘or’ of equal expressions" warning on linux.
* Fixed a benign switch fallthrough warning.
* Added missing `push/pop_options.hpp` includes.
* Suppressed zero-as-null-pointer-constant warnings.
* Fixed a comma-operator warning.
* Updated the documentation to clarify when the [^select] reactor is used on
  Windows.
* Fixed potential ambiguity caused by `any_executor` comparisons and conversion.
* Added detection of non-experimental C++20 coroutines on MSVC 19.8.
* Fixed compatibility with uClibc.
* Fixed `strand<>` adaptation of Networking TS executors when targeting older
  C++ versions or less conformant compilers.

[heading Asio 1.18.0 / Boost 1.74]

* Added an implementation of the proposed standard executors
	([@http://wg21.link/P0443r13 P0443r13], [@http://wg21.link/P1348r0 P1348r0],
  and [@http://wg21.link/P1393r0 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:[br]
  ``
  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));
  ``[br]
* Enabled C++20 coroutine support when using [^gcc] 10.
* Added overloads of `co_spawn` that launch an awaitable. This change allows us
  to write:[br]
  ``
  co_spawn(executor,
      echo(std::move(socket)),
      detached);
  ``[br]
  instead of:[br]
  ``
  co_spawn(executor,
      [socket = std::move(socket)]() mutable
      {
        return echo(std::move(socket));
      },
      detached);
  ``[br]
* 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:
  [pre
  @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|][br]
  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
  ``[br]
* 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:
  [pre
  cat output.txt | perl handlertree.pl 123 456]
  or:
  [pre
  perl handlertree.pl 123 456 < output.txt][br]
  This script may be combined with handerlive.pl and handlerviz.pl to produce a
  graph of the "live" asynchronous operation chains. For example:
  [pre
  cat output.txt | \
    perl handlertree.pl `perl handlerlive.pl output.txt` | \
    perl handlerviz.pl | \
    dot -Tsvg > output.svg][br]
* 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.

[heading 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.

[heading 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;
  ``[br]
* 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{}
    );
  ``[br]
  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.
  ``[br]
  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.
  ``[br]
* 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>
  ``[br]
  then your accepted socket type will be:
  ``
  basic_stream_socket<ip::tcp, my_executor_type>
  ``[br]
* 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.

[heading 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.

[heading 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());
    ``[br]
    To fix this, either construct the second I/O object using the first I/O
    object's executor:[br]
    ``
    asio::steady_timer my_timer(my_socket.get_executor());
    ``[br]
    or otherwise explicitly pass the `io_context`:[br]
    ``
    asio::steady_timer my_timer(my_io_context);
    ``[br]
  * 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);
    };
    ``[br]
  * 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:[br]
    ``
      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));
      }
    ``[br]
  * 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.

[heading 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.

[heading 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.

[heading Asio 1.12.0 / Boost 1.66]

* Implemented interface changes to reflect the Networking TS
	([@www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4656.pdf N4656]).
	* See the [link boost_asio.net_ts 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 [link boost_asio.overview.core.configuration 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.)

[heading 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 ([ticket 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 ([ticket 12419]).
* Fixed MSVC intellisense detection.
* Disabled use of the `__thread` keyword extension for android/clang/x86
  targets.

[heading 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] ([ticket
  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 ([ticket 12482]).
* Added a workaround for broken `getaddrinfo` in Apple's NAT64 environment.
* Fixed an exception safety issue in the internal hash map implementation.

[heading Asio 1.10.8 / Boost 1.62]

* Added compatibility with OpenSSL 1.1.0 ([ticket 12238]).
* Fixed out-of-bounds iterator use in `asio::connect()` when the
  `connect_condition` returns an end iterator ([ticket 12354]).
* Added a workaround for a move detection problem on MSVC 2015 Update 2
  ([ticket 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 ([ticket
  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 ([ticket
  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`.

[heading 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
  ([ticket 11539]).
* Changed Asio's SSL wrapper to respect OpenSSL's `OPENSSL_NO_SSL3` feature
  test `#define` ([ticket 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 ([ticket 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` ([ticket 11732]).

[heading Asio 1.10.6 / Boost 1.58]

* Ensured errors generated by Windows' `ConnectEx` function are mapped to their
  portable equivalents ([ticket 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 ([ticket 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 ([ticket 9465], [ticket 11070]).
* Changed the SSL wrapper to call the password callback when loading an
  in-memory key ([ticket 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 ([ticket 10088]).
* Added options for disabling TLS v1.1 and v1.2 ([ticket 10690]).
* Removed use of deprecated OpenSSL function `ERR_remove_state`.
* Fixed detection of various C++11 features with Clang ([ticket 8835],
  [ticket 10884]).
* Fixed detection of C++11 `std::addressof` with [^g++] ([ticket 10982]).
* Changed multicast test to treat certain `join_group` failures as non-fatal.
* Decoupled Asio unit tests from Boost.Test ([ticket 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.

[heading Asio 1.10.5 / Boost 1.57]

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

[heading 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.

[heading Asio 1.10.3]

* Worked around a [^gcc] problem to do with anonymous enums ([ticket 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 ([ticket 10034]).
* Fixed an off-by-one error in the `signal_set` implementation's signal
  number check ([ticket 9324]).
* Changed the Windows IOCP backend to not assume that
  `SO_UPDATE_CONNECT_CONTEXT` is defined ([ticket 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.

[heading Asio 1.10.2]

* Fixed `asio::spawn()` to work correctly with new Boost.Coroutine interface
  ([ticket 9442], [ticket 9928]).
* Ensured that incomplete `asio::spawn()` coroutines are correctly unwound when
  cleaned up by the `io_service` destructor ([ticket 9731]).
* Fixed delegation of continuation hook for handlers produced by
  `io_service::wrap()` and `strand::wrap()` ([ticket 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 ([ticket 9662], [ticket 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~` ([ticket 9548]).
* Made the `select` reactor more efficient on Windows for large numbers of
  sockets ([ticket 9528]).
* Fixed a Windows-specific type-aliasing issue reported by [^gcc] ([ticket
  9550]).
* Prevented execution of compile-time-only buffer test to avoid triggering an
  address sanitiser warning ([ticket 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 ([ticket 8295], [ticket 9605],
  [ticket 9771]).

[heading 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 ([ticket 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 ([ticket 8933]).
* Fixed a bug in handler tracking, where it was not correctly printing out some
  handler IDs ([ticket 8808]).
* Fixed the comparison used to test for successful synchronous accept
  operations so that it works correctly with unsigned socket descriptors
  ([ticket 8752]).
* Ensured the signal number is correctly passed to the completion handler when
  starting an `async_wait` on a signal that is already raised ([ticket 8738]).
* Suppressed a g++ 4.8+ warning about unused typedefs ([ticket 8980]).
* Enabled the move optimisation for handlers that use the default invocation
  hook ([ticket 8624]).
* Clarified that programs must not issue overlapping `async_write_at`
  operations ([ticket 8669]).
* Changed the Windows `HANDLE` backend to treat `ERROR_MORE_DATA` as a
  non-fatal error when returned by `GetOverlappedResult` for a synchronous
  read ([ticket 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 ([ticket 9000],
  [ticket 9001]).
* Enabled move support for Microsoft Visual Studio 2012 ([ticket 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 ([ticket 8758]).
* Eliminated some unnecessary handler copies.
* Fixed support for older versions of OpenSSL that do not provide the
  `SSL_CTX_clear_options` function ([ticket 9273]).
* Fixed various minor and cosmetic issues in code and documentation
  (including [ticket 8347], [ticket 8950], [ticket 8953], [ticket 8965],
  [ticket 8997], [ticket 9230]).

[heading 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 [link boost_asio.overview.composition.spawn
  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 [link boost_asio.overview.composition.futures
  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 [link boost_asio.overview.composition.coroutine
  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 [link
  boost_asio.overview.networking.other_protocols 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 [link
  boost_asio.overview.networking.other_protocols 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 [link
  boost_asio.overview.networking.other_protocols 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 [ticket 8421].
* Fixed copy-paste errors in waitable timer documentation [ticket 8602].
* Added assertions to satisfy some code analysis tools [ticket 7739].
* Fixed a malformed `#warning` directive [ticket 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` [ticket 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
  [ticket 8354].
* Fixed implementation of asynchronous connect operation so that it can cope
  with spurious readiness notifications from the reactor [ticket 7961].
* Fixed a memory leak in the `ssl::rfc2818_verification` class.
* Added a mechanism for disabling automatic Winsock initialisation [ticket
  3605]. See the header file [^boost/asio/detail/winsock_init.hpp] for details.

[heading Asio 1.8.3 / Boost 1.53]

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

[heading Asio 1.8.2 / Boost 1.51]

* Fixed an incompatibility between `ip::tcp::iostream` and C++11
  ([@https://svn.boost.org/trac/boost/ticket/7162 #7162]).
* Decorated GCC attribute names with underscores to prevent interaction
  with user-defined macros
  ([@https://svn.boost.org/trac/boost/ticket/6415 #6415]).
* Added missing `#include <cctype>`, needed for some versions of MinGW.
* Changed to use [^gcc]'s atomic builtins on ARM CPUs, when available
  ([@https://svn.boost.org/trac/boost/ticket/7140 #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`
  ([@https://svn.boost.org/trac/boost/ticket/7012 #7012]).
* Changed the SSL implementation to throw an exception if SSL engine
  initialisation fails
  ([@https://svn.boost.org/trac/boost/ticket/6303 #6303]).
* Fixed another regression in `buffered_write_stream`
  ([@https://svn.boost.org/trac/boost/ticket/6310 #6310]).
* Implemented various minor performance improvements, primarily targeted at
  Linux x86 and x86-64 platforms.

[heading 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` ([@https://svn.boost.org/trac/boost/ticket/6432 #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
  ([@https://svn.boost.org/trac/boost/ticket/6620 #6620]).
* Fixed a problem where `signal_set` handlers were not being delivered when
  the `io_service` was constructed with a `concurrency_hint` of 1
  ([@https://svn.boost.org/trac/boost/ticket/6657 #6657]).

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/6048 #6048]).
* Fixed a compile error on NetBSD
  ([@https://svn.boost.org/trac/boost/ticket/6098 #6098]).
* Fixed deadlock on Mac OS X
  ([@https://svn.boost.org/trac/boost/ticket/6275 #6275]).
* Fixed a regression in `buffered_write_stream`
  ([@https://svn.boost.org/trac/boost/ticket/6310 #6310]).
* Fixed a non-paged pool "leak" on Windows when an `io_service` is repeatedly
  run without anything to do
  ([@https://svn.boost.org/trac/boost/ticket/6321 #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.

[heading 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`
  ([@https://svn.boost.org/trac/boost/ticket/5688 #5688]).
* Fixed a Windows-specific compile error by explicitly specifying the
  `signal()` function from the global namespace
  ([@https://svn.boost.org/trac/boost/ticket/5722 #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 ([@https://svn.boost.org/trac/boost/ticket/5854 #5854]).
* Fixed the behaviour of the synchronous `null_buffers` operations so that they
  obey the user's non-blocking setting
  ([@https://svn.boost.org/trac/boost/ticket/5756 #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
  ([@https://svn.boost.org/trac/boost/ticket/5763 #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
  ([@https://svn.boost.org/trac/boost/ticket/5999 #5999]).
* Fixed an exception safety issue in `epoll_reactor` initialisation
  ([@https://svn.boost.org/trac/boost/ticket/6006 #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.

[heading 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 [@https://svn.boost.org/trac/boost/ticket/2879 #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 [@https://svn.boost.org/trac/boost/ticket/3702 #3702],
  [@https://svn.boost.org/trac/boost/ticket/3958 #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 ([@https://svn.boost.org/trac/boost/ticket/5453 #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
  ([@https://svn.boost.org/trac/boost/ticket/3939 #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
  ([@https://svn.boost.org/trac/boost/ticket/3297 #3297]).
* Added a `release()` member function to posix descriptors. This function
  releases ownership of the underlying native descriptor to the caller.
  Addresses [@https://svn.boost.org/trac/boost/ticket/3900 #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
  [@https://svn.boost.org/trac/boost/ticket/3238 #3238],
  [@https://svn.boost.org/trac/boost/ticket/4162 #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
  [@https://svn.boost.org/trac/boost/ticket/3307 #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 ([@https://svn.boost.org/trac/boost/ticket/3741 #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
  ([@https://svn.boost.org/trac/boost/ticket/4971 #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
  ([@https://svn.boost.org/trac/boost/ticket/3905 #3905]).
* Added an explicit cast to convert the `FIONBIO` constant to int, to suppress
  a compiler warning on some platforms
  ([@https://svn.boost.org/trac/boost/ticket/5128 #5128]).
* Changed most examples to treat a failure by an accept operation as non-fatal
  ([@https://svn.boost.org/trac/boost/ticket/5124 #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 ([@https://svn.boost.org/trac/boost/ticket/5418 #5418]).

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/5021 #5021]).
* Fixed compile failures with some versions of [^g++] due to the use of
  anonymous enums ([@https://svn.boost.org/trac/boost/ticket/4883 #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.

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/5045 #5045]).

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

[heading Asio 1.4.6 / Boost 1.44]

* Reduced compile times. (Note that some programs may need to add additional
  `#include`s, 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`
  ([@https://svn.boost.org/trac/boost/ticket/4170 #4170]).
* Ensured `unsigned char` is used with `isdigit` in `getaddrinfo` emulation
  ([@https://svn.boost.org/trac/boost/ticket/4201 #4201]).
* Fixed handling of very small but non-zero timeouts
  ([@https://svn.boost.org/trac/boost/ticket/4205 #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`
  ([@https://svn.boost.org/trac/boost/ticket/4382 #4382]).
* Implemented cancellation of `null_buffers` operations on Windows.

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/3923 #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
  ([@https://svn.boost.org/trac/boost/ticket/3901 #3901]).
* Fixed a bug where 0-byte asynchronous reads were incorrectly passing an
  `error::eof` result to the completion handler
  ([@https://svn.boost.org/trac/boost/ticket/4023 #4023]).
* Changed the `io_control()` member functions to always call `ioctl` on the
  underlying descriptor when modifying blocking mode
  ([@https://svn.boost.org/trac/boost/ticket/3307 #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.

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/2977 #2977]).
* Restricted MSVC buffer debugging workaround to 2008, as it causes a crash with
  2010 beta 2 ([@https://svn.boost.org/trac/boost/ticket/3796 #3796],
  [@https://svn.boost.org/trac/boost/ticket/3822 #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
  ([@https://svn.boost.org/trac/boost/ticket/3626 #3626]).
* Added a `boost_` prefix to the `extern "C"` thread entry point function
  ([@https://svn.boost.org/trac/boost/ticket/3809 #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
  ([@https://svn.boost.org/trac/boost/ticket/3670 #3670]).
* Added some support for platforms that use older compilers such as g++ 2.95
  ([@https://svn.boost.org/trac/boost/ticket/3743 #3743]).

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/2754 #2754]).
* Made Asio compatible with the OpenSSL 1.0 beta
  ([@https://svn.boost.org/trac/boost/ticket/3256 #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
  ([@https://svn.boost.org/trac/boost/ticket/3095 #3095]).
* Ensured correct propagation of the error code when a synchronous accept fails
  ([@https://svn.boost.org/trac/boost/ticket/3216 #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
  ([@https://svn.boost.org/trac/boost/ticket/3098 #3098]).
* Fixed custom memory allocation support for timers
  ([@https://svn.boost.org/trac/boost/ticket/3107 #3107]).
* Tidied up various warnings reported by g++
  ([@https://svn.boost.org/trac/boost/ticket/1341 #1341],
  [@https://svn.boost.org/trac/boost/ticket/2618 #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
  ([@https://svn.boost.org/trac/boost/ticket/3157 #3157],
  [@https://svn.boost.org/trac/boost/ticket/2620 #2620]).

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/2682 #2682]).
* Fix a memory leak that occurred when an asynchronous SSL operation's
  completion handler threw an exception
  ([@https://svn.boost.org/trac/boost/ticket/2910 #2910]).
* Fix the implementation of `io_control()` so that it adheres to the
  documented type requirements for IoControlCommand
  ([@https://svn.boost.org/trac/boost/ticket/2820 #2820]).
* Fix incompatibility between Asio and ncurses.h
  ([@https://svn.boost.org/trac/boost/ticket/2156 #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
  ([@https://svn.boost.org/trac/boost/ticket/2936 #2936]).
* Fix system call wrappers to always clear the error on success, as POSIX
  allows successful system calls to modify errno 
  ([@https://svn.boost.org/trac/boost/ticket/2953 #2953]).
* Don't include termios.h if `BOOST_ASIO_DISABLE_SERIAL_PORT` is defined
  ([@https://svn.boost.org/trac/boost/ticket/2917 #2917]).
* Cleaned up some more MSVC level 4 warnings
  ([@https://svn.boost.org/trac/boost/ticket/2828 #2828]).
* Various documentation fixes
  ([@https://svn.boost.org/trac/boost/ticket/2871 #2871]).

[heading 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
  ([@https://svn.boost.org/trac/boost/ticket/2614 #2614]).
* Fixed a link problem and multicast failure on QNX
  ([@https://svn.boost.org/trac/boost/ticket/2504 #2504],
  [@https://svn.boost.org/trac/boost/ticket/2530 #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 ([@https://svn.boost.org/trac/boost/ticket/2683 #2683]).
* Various minor bug and documentation fixes
  ([@https://svn.boost.org/trac/boost/ticket/2534 #2534],
  [@https://svn.boost.org/trac/boost/ticket/2541 #2541],
  [@https://svn.boost.org/trac/boost/ticket/2607 #2607],
  [@https://svn.boost.org/trac/boost/ticket/2617 #2617],
  [@https://svn.boost.org/trac/boost/ticket/2619 #2619]).

[heading 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.

[heading 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 `HANDLE`s such as named pipes
  (requires `HANDLE`s that work with I/O completion ports).
* Added wrappers for Windows random-access `HANDLE`s such as files (requires
  `HANDLE`s 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.

[heading Asio 1.0.0 / Boost 1.35]

First release of Asio as part of Boost.

[endsect]
