| [/ |
| / Copyright (c) 2003-2021 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.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: |
| `` |
| @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: |
| `` |
| cat output.txt | perl handlertree.pl 123 456 |
| `` |
| or: |
| `` |
| 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: |
| `` |
| 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.concurrency_hint 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.core.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.cpp2011.futures C++ |
| 2011 Support - Futures]. |
| * Promoted the stackless coroutine class and macros to be part of Asio's |
| documented interface, rather than part of the HTTP server 4 example. |
| For further information, see [link boost_asio.overview.core.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] |