1[/ 2 / Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) 3 / 4 / Distributed under the Boost Software License, Version 1.0. (See accompanying 5 / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 /] 7 8[section:history Revision History] 9 10[heading Asio 1.18.2 / Boost 1.76] 11 12* Added `ip::scope_id_type` type alias. 13* Added `ip::port_type` type alias. 14* Added `std::hash` specialisations for IP addresses. 15* Added `std::hash` specialisations for `ip::basic_endpoint<>`. 16* Refactored SFINAE usage to improve compile times. 17* Added friendship support to customisation points, and made most customisations private. 18* Changed `any_io_executor` to a "strong typedef"-style class. 19* Fixed `experimental::as_single` to work with handler hook deprecation. 20* Ensured pthread condition variable attributes are cleaned up on all platforms. 21* Clarified thread safety notes on sockets and descriptors. 22* Ensured `errno` is not overwritten if `socket()` fails on macOS/FreeBSD. 23* Fixed work tracking for `io_context` and `thread_pool` executors when move-assigned. 24* Ensured internal `call_stack` objects are accessed only from implementation files. 25* Fixed I/O object move-assignment to ensure the executor is left in a valid state. 26* Fixed detection of compiler support for defaulted template argument on functions with MSVC. 27* Prevented the `blocking.always` property from being used with `strand<>`, as it 28 did not produce the correct semantics. 29* Removed deprecated file [^asio/impl/src.cpp]. 30 31[heading Asio 1.18.1 / Boost 1.75] 32 33* Enabled support for UNIX domain sockets on Windows. From Windows 10, UNIX 34 domain sockets (a.k.a "local" sockets) are supported on Windows, with the 35 exception of the `connect_pair` function (which will fail with an 36 operation_not_supported error). 37* Added executor-converting construction and assignment to `ip::basic_resolver`. 38* Added compatibility between polymorphic executors and the (deprecated) handler 39 invocation hook. 40* Added the `experimental::as_single` completion token adapter. The `as_single` 41 completion token adapter can be used to specify that the completion handler 42 arguments should be combined into a single argument. For completion signatures 43 with a single parameter, the argument is passed through as-is. For signatures 44 with two or more parameters, the arguments are combined into a tuple. The 45 `as_single` adapter may be used in conjunction with `use_awaitable` and 46 structured bindings as follows:[br] 47 `` 48 auto [e, n] = co_await socket.async_read_some( 49 boost::asio::buffer(data), as_single(use_awaitable)); 50 ``[br] 51 Alternatively, it may be used as a default completion token like so:[br] 52 `` 53 using default_token = as_single_t<use_awaitable_t<>>; 54 using tcp_socket = default_token::as_default_on_t<tcp::socket>; 55 // ... 56 awaitable<void> do_read(tcp_socket socket) 57 { 58 // ... 59 auto [e, n] = co_await socket.async_read_some(boost::asio::buffer(data)); 60 // ... 61 } 62 ``[br] 63* Added support for `MSG_NOSIGNAL` on more platforms by using `_POSIX_VERSION` 64 to detect whether it is supported. 65* Added the ability to compile using libpthread on Windows. 66* Added workarounds for the Intel C++ compiler. 67* Added more support for detecting and optimising for handlers that have no 68 custom executor. 69* Reduced lock contention for timer cancellation on Windows. 70* Reinstated a previously removed null-pointer check, as it had a measurable 71 impact on performance. 72* Fixed the `executor` concept to test for a const-qualified `execute()`. 73* Fixed `any_executor` support for builds without RTTI support. 74* Fixed the `thread_pool` unit test to work without RTTI support. 75* Fixed C++20 coroutines compatibility with clang on Windows. 76* Fixed some compatibility issues with Windows Runtime. 77* Fixed shadow name warnings caused by addition of `asio::query`. 78* Fixed a "logical ‘or’ of equal expressions" warning on linux. 79* Fixed a benign switch fallthrough warning. 80* Added missing `push/pop_options.hpp` includes. 81* Suppressed zero-as-null-pointer-constant warnings. 82* Fixed a comma-operator warning. 83* Updated the documentation to clarify when the [^select] reactor is used on 84 Windows. 85* Fixed potential ambiguity caused by `any_executor` comparisons and conversion. 86* Added detection of non-experimental C++20 coroutines on MSVC 19.8. 87* Fixed compatibility with uClibc. 88* Fixed `strand<>` adaptation of Networking TS executors when targeting older 89 C++ versions or less conformant compilers. 90 91[heading Asio 1.18.0 / Boost 1.74] 92 93* Added an implementation of the proposed standard executors 94 ([@http://wg21.link/P0443r13 P0443r13], [@http://wg21.link/P1348r0 P1348r0], 95 and [@http://wg21.link/P1393r0 P1393r0]). 96* Added support for the proposed standard executors to Asio's I/O facilities: 97 * The `io_context::executor_type`, `thread_pool::executor_type`, 98 `system_executor`, and `strand` executors now meet the requirements for the 99 proposed standard executors. These classes also continue to meet the 100 existing requirements for the Networking TS model of executors. 101 * All I/O objects, asynchronous operations, and utilities including 102 `dispatch`, `post`, `defer`, `get_associated_executor`, `bind_executor`, 103 `make_work_guard`, `spawn`, `co_spawn`, `async_compose`, `use_future`, 104 etc., can interoperate with both new proposed standard executors, and with 105 existing Networking TS executors. The implementation determines at compile 106 time which model a particular executor meets; the proposed standard 107 executor model is used in preference if both are detected. 108 * The `any_io_executor` type alias has been introduced as the new default 109 runtime-polymorphic executor for all I/O objects. This type alias points to 110 the `execution::any_executor<>` template with a set of supportable 111 properties specified for use with I/O. This change may break existing code 112 that directly uses the old polymorphic wrapper, `executor`. If required for 113 backward compatibility, `BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT` can be 114 defined, which changes the `any_io_executor` type alias to instead point to 115 the `executor` polymorphic wrapper. 116 * Support for the existing Networking TS model of executors can be disabled 117 by defining `BOOST_ASIO_NO_TS_EXECUTORS`. 118* Added converting move construction and assignment to `basic_waitable_timer`. 119 This enables move construction and assignment between different timer 120 types, provided the executor types are convertible. For example:[br] 121 `` 122 basic_waitable_timer< 123 clock_type, 124 traits_type, 125 io_context::executor_type 126 > timer1(my_io_context); 127 128 basic_waitable_timer< 129 clock_type, 130 traits_type, 131 any_io_executor // polymorphic wrapper 132 > timer2(std::move(timer1)); 133 ``[br] 134* Enabled C++20 coroutine support when using [^gcc] 10. 135* Added overloads of `co_spawn` that launch an awaitable. This change allows us 136 to write:[br] 137 `` 138 co_spawn(executor, 139 echo(std::move(socket)), 140 detached); 141 ``[br] 142 instead of:[br] 143 `` 144 co_spawn(executor, 145 [socket = std::move(socket)]() mutable 146 { 147 return echo(std::move(socket)); 148 }, 149 detached); 150 ``[br] 151* Added a new constructor overload to `use_awaitable_t`'s default executor 152 adapter, to enable conversion between executor types. 153* Added support for using `detached_t` as a default completion token, by 154 adding members `as_default_on()` and `as_default_on_t<>`. 155* Added a move constructor to `ssl::stream<>`. 156* Changed `ssl::stream<>` write operations to linearise gather-write buffer 157 sequences. 158* Added compile-time detection of the deprecated `asio_handler_invoke` hook. 159 This hook was deprecated with the introduction of the Networking TS trait 160 `associated_executor` and function `get_associated_executor()`. Compiling 161 an application with `BOOST_ASIO_NO_DEPRECATED` will now trigger a compile 162 error if any handler implements the `asio_handler_invoke` hook. 163* Added compile-time detection of the deprecated `asio_handler_allocate` 164 and `asio_handle_deallocate` hooks. These hooks were deprecated with the 165 introduction of the Networking TS trait `associated_allocator` and function 166 `get_associated_allocator()`. Compiling an application with 167 `BOOST_ASIO_NO_DEPRECATED` will now trigger a compile error if any handler 168 implements the `asio_handler_allocate` or `asio_handler_deallocate` hooks. 169* Implemented a number of performance optimisations, including: 170 * Specialising single-buffer operations to use `recv` rather than `recvmsg`, 171 `send` rather than `sendmsg`, `read` rather than `readv`, and `write` 172 rather than `writev`. 173 * Lightening the reference counting overhead of the polymorphic wrapper 174 `executor`. 175 * Returning from system call operation wrappers as early as possible, and 176 only accessing `errno` and error codes when on an error path. 177 * Applying additional optimisations if a "native" I/O executor (such as 178 `io_context::exeutor_type`) is detected. 179* Added source location support to handler tracking. The new 180 `BOOST_ASIO_HANDLER_LOCATION((file_name, line, function_name))` macro may be used 181 to inform the handler tracking mechanism of a source location. This macro 182 declares an object that is placed on the stack. Then, when an asynchronous 183 operation is launched with location information, it outputs lines using the 184 [*<action>] [^n^m], prior to the [^n*m] line that signifies the beginning 185 of the asynchronous operation. For example: 186 `` 187 @asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5 188 @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330) 189 @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62) 190 @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51) 191 @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send 192 @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5 193 @asio|1589423304.861980|<7| 194 ``[br] 195 If `std::source_location` or `std::experimental::source_location` are 196 available, the `use_awaitable_t` token (when default-constructed or used as a 197 default completion token) will also cause handler tracking to output a source 198 location for each newly created asynchronous operation. A `use_awaitable_t` 199 object may also be explicitly constructed with location information. 200* Implemented various improvements to the [^handlerviz.pl] tool. 201 * Add nodes for pending handlers at bottom of graph, outlined in red. 202 * Display source location in a tooltip on the edge label (for SVG). 203 * Use invisible nodes to enforce order to keep related control flow vertical. 204* Added the [^handlerlive.pl] tool, which processes handler tracking output to 205 produce a list of "live" handlers. Live handlers are those that are 206 associated with pending asynchronous operations, as well as handlers that are 207 currently executing. For example: 208 `` 209 cat output.txt | perl handlerlive.pl 210 `` 211 or: 212 `` 213 perl handerlive.pl < output.txt 214 `` 215 or: 216 `` 217 perl handlerlive.pl output.txt 218 ``[br] 219* Added the [^handlertree.pl] tool, which filters handler tracking output to 220 include only those events in the tree that produced the nominated handlers. 221 For example, to filter the output to include only the events associated with 222 handlers `123`, `456`, and their predecessors: 223 `` 224 cat output.txt | perl handlertree.pl 123 456 225 `` 226 or: 227 `` 228 perl handlertree.pl 123 456 < output.txt 229 ``[br] 230 This script may be combined with handerlive.pl and handlerviz.pl to produce a 231 graph of the "live" asynchronous operation chains. For example: 232 `` 233 cat output.txt | \ 234 perl handlertree.pl `perl handlerlive.pl output.txt` | \ 235 perl handlerviz.pl | \ 236 dot -Tsvg > output.svg 237 ``[br] 238* Added changes for clang-based Embarcadero C++ compilers. 239* Fixed a deadlock that can occur when multiple threads concurrently initialise 240 the Windows I/O completion port backend. 241* Fixed `async_compose` to work with copyable handlers when passed by lvalue. 242* Fixed completion signature deduction in `co_spawn`. 243* Removed a spurious `Executor` base class from the `executor_binder` 244 implementation. 245* Various fixes and improvements in the documentation and examples. 246 247[heading Asio 1.16.1 / Boost 1.73] 248 249* Fixed compatibility with C++20 concept syntax. 250* Marked the POSIX descriptor classes' move constructors as `noexcept`. 251* Added the `ssl::host_name_verification` class, which is a drop-in replacement 252 for `ssl::rfc2818_verification`. The `ssl::rfc2818_verification` class has 253 been marked as deprecated. As a consequence of this change, SSL support now 254 depends on functions that were introduced in OpenSSL 1.0.2. 255* Added an `ssl::context` constructor to take ownership of a native handle. 256* Changed C++ language version detection with [^gcc] to use `__cplusplus` macro. 257* Fixed a work counting issue in the asynchronous resolve operation for 258 endpoints. 259* Fixed the `strand<>` converting constructors and assignment operators. 260* Ensured that resolvers are restarted correctly after a fork. 261* Fixed compatibility with the current NetBSD release. 262* Removed spurious handler requirement checks in some `async_read` overloads. 263* Changed the `ssl::context` class to propagate non-EOF errors from the 264 `add_certificate_authority` function. 265* Fixed a Windows-specific `thread_pool` destructor hang that occurred when the 266 pool had an associated I/O object. 267* Changed the [^select] reactor to recreate the "self pipe trick" sockets on 268 error. This addresses an issue on some versions of Windows, where these 269 sockets are discconected after a system sleep. 270* Fixed a compile error in the buffered streams due to the lack of reference 271 collapsing in C++98. 272* Changed the `priority_scheduler` example to demonstrate calls to `shutdown()` 273 and `destroy()`. 274* Removed some unnecessary null pointer checks. 275* Changed Windows platform detection to recognise TV titles as Windows apps. 276* Added some emscripten compatibility patches. 277* Fixed a compile error in the `use_awaitable_t::as_default_on` function. 278* Changed all uses of the boost.bind placeholders to use the 279 `boost::placeholders` namespace. 280* Fixed a potential compile error in the `async_compose` implementation due to 281 incorrect overload selection. 282* Suppressed some non-virtual destructor warnings. 283* Various documentation fixes and improvements. 284 285[heading Asio 1.16.0 / Boost 1.72] 286 287* Changed the `async_initiate` helper function to automatically deduce its 288 return type. This is enabled for C++11 or later. 289* Changed all asynchronous operations to use automatically deduced return 290 types. This allows completion token implementations to incorporate the 291 asynchronous operation initiation into the initiating function's return type, 292 without type erasure. Note that C++14 or later is required to support 293 completion tokens that use per-operation return type deduction. For C++11 or 294 earlier, a completion token's async_result specialisation must still provide 295 the nested typedef `return_type`. 296* Introduced three new concepts to support `async_initiate`. 297 * `completion_signature<T>`: Checks if `T` is a signature of the form 298 `R(Args...)`. 299 * `completion_handler_for<T, Signature>`: Checks if `T` is usable as a 300 completion handler with the specified signature. 301 * `completion_token_for<T, Signature>`: Checks if `T` is a completion token 302 that can be used with async_initiate and the specified signature. 303 * For backward compatibility with pre-concepts C++, the macros 304 `BOOST_ASIO_COMPLETION_SIGNATURE`, `BOOST_ASIO_COMPLETION_HANDLER_FOR`, and 305 `BOOST_ASIO_COMPLETION_TOKEN_FOR` are provided. These macros expand to 306 `typename` when concepts are unsupported. 307* Added the nested template type `rebind_executor` to all I/O object types, as 308 a way to generically rebind them to use alternative I/O executors. For 309 example: 310 `` 311 using my_socket_type = tcp::socket::rebind_executor<my_executor_type>::other; 312 ``[br] 313* Changed the asynchronous operations' initiation function objects to report 314 their associated I/O executor via the nested type `executor_type` and member 315 function `get_executor()`. Note that the presence of `executor_type` and 316 `get_executor()` should be treated as optional, and consequently it may be 317 preferable to access them via the `associated_executor` trait and the 318 `get_associated_executor()` helper function. 319* Added the `default_completion_token` trait, so that every I/O executor type 320 now has an associated default completion token type. This trait may be used 321 in asynchronous operation declarations as follows: 322 `` 323 template < 324 typename IoObject, 325 typename CompletionToken = 326 typename default_completion_token< 327 typename IoObject::executor_type 328 >::type 329 > 330 auto async_fyz( 331 IoObject& io_object, 332 CompletionToken&& token = 333 typename default_completion_token< 334 typename IoObject::executor_type 335 >::type{} 336 ); 337 ``[br] 338 If not specialised, this trait type is `void`, meaning no default completion 339 token type is available for the given I/O executor. 340* Specialised the `default_completion_token` trait for the `use_awaitable` 341 completion token, so that it may be used as shown in the following example: 342 `` 343 auto socket = use_awaitable.as_default_on(tcp::socket(my_context)); 344 // ... 345 co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable. 346 ``[br] 347 In this example, the type of the `socket` object is transformed from 348 `tcp::socket` to have an I/O executor with the default completion token set 349 to `use_awaitable`. Alternatively, the socket type may be computed directly: 350 `` 351 using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>; 352 tcp_socket socket(my_context); 353 // ... 354 co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable. 355 ``[br] 356* Added missing `async_initiate` to the Windows-specific I/O objects' 357 asynchronous operations. 358* Ensured that the executor type is propagated to newly accepted sockets. 359 When synchronously or asynchronously accepting a new connection, but 360 without specifying an executor or execution context, the accept 361 operation will now correctly propagate the executor type from the 362 acceptor to the socket. For example, if your acceptor type is: 363 `` 364 basic_socket_acceptor<ip::tcp, my_executor_type> 365 ``[br] 366 then your accepted socket type will be: 367 `` 368 basic_stream_socket<ip::tcp, my_executor_type> 369 ``[br] 370* Changed to require that `Protocol` copy and move operations never throw. 371* Changed to require that `Endpoint` default constructor and move operations 372 never throw. 373* Added the `noexcept` qualifier to protocol accessors. 374* Added the `noexcept` qualifier to socket move constructors. 375* Fixed issues associated with opening serial ports on Windows: 376 * Use the correct constant to initialise the RTS control flag. 377 * Specify a default baud rate (9600). 378* Fixed a lost "outstanding work count" that can occur when an asynchronous 379 accept operation is automatically restarted. 380 381[heading Asio 1.14.1 / Boost 1.71] 382 383* Improved performance slightly by eliminating a redundant move construction 384 when completed handlers are dispatched. 385* Eliminated a compiler warning by annotating a `case` fall-through in 386 the free function `connect()` implementation. 387* Fixed the `is_*_buffer_sequence` detection traits for user-defined sequence 388 types. 389* Fixed some Windows-specific warnings about an incompatible pointer cast when 390 obtaining the `CancelIoEx` entry point. 391* Changed to automatically set the defaults when opening a serial port on 392 Windows. 393* Changed the serial port `get_option()` member function to be const. 394* Fixed a name hiding issue with the WinRT stream-oriented socket backend's 395 `shutdown` function. 396* Applied a minor fix to the documentation for `is_dynamic_buffer`. 397* Added some support for Haiku OS. 398* Added wolfSSL compatability. 399* Changed to require C++17 or later for coroutines TS support with clang. 400* Fixed a doxygen generation problem in the tutorial. 401* Ensured example programs are correctly incorporated into the documentation. 402 403[heading Asio 1.14.0 / Boost 1.70] 404 405* Added custom I/O executor support to I/O objects. 406 * All I/O objects now have an additional `Executor` template parameter. This 407 template parameter defaults to the `asio::executor` type (the polymorphic 408 executor wrapper) but can be used to specify a user-defined executor 409 type. 410 * I/O objects' constructors and functions that previously took an 411 `asio::io_context&` now accept either an `Executor` or a reference to a 412 concrete `ExecutionContext` (such as `asio::io_context` or 413 `asio::thread_pool`). 414 * Note: One potential source of breakage in existing user code is when reusing an 415 I/O object's `io_context` for constructing another I/O object, as in: 416 `` 417 asio::steady_timer my_timer(my_socket.get_executor().context()); 418 ``[br] 419 To fix this, either construct the second I/O object using the first I/O 420 object's executor:[br] 421 `` 422 asio::steady_timer my_timer(my_socket.get_executor()); 423 ``[br] 424 or otherwise explicitly pass the `io_context`:[br] 425 `` 426 asio::steady_timer my_timer(my_io_context); 427 ``[br] 428 * The previously deprecated `get_io_context` and `get_io_service` 429 member functions have now been removed. 430 * The previously deprecated service template parameters, and the 431 corresponding classes, have now been removed. 432* Added a new `async_result` form with an `initiate` static member function. 433 * The `async_result` template now supports a new form: 434 `` 435 template <typename CompletionToken, typename Signature> 436 struct async_result 437 { 438 typedef /* ... */ return_type; 439 440 template <typename Initiation, 441 typename RawCompletionToken, 442 typename... Args> 443 static return_type initiate( 444 Initiation&& initiation, 445 RawCompletionToken&& token, 446 Args&&... args); 447 }; 448 ``[br] 449 * The `initiate` member function must: (a) transform the token into a 450 completion handler object `handler`; (b) cause the invocation of the 451 function object `initiation` as if by calling 452 `std::forward<Initiation>(initiation)(std::move(handler), 453 std::forward<Args>(args)...)`. Note that the invocation of `initiation` 454 may be deferred (e.g. lazily evaluated), in which case `initiation` and 455 `args` must be decay-copied and moved as required. 456 * A helper function template `async_initiate` has also been added as a 457 wrapper for the invocation of `async_result<>::initiate`. For backward 458 compatibility, this function supports both the old and new `async_result` 459 forms. 460 * The composed operations examples have been updated to use `async_initiate`. 461 * The previously deprecated `handler_type` trait and single-argument form of 462 `async_result` have now been removed. 463* Updated the Coroutines TS support and promoted it to the `asio` namespace. 464 * The `awaitable<>`, `co_spawn`, `this_coro`, `detached`, and 465 `redirect_error` facilities have been moved from the `asio::experimental` 466 namespace to namespace `asio`. As part of this change, the 467 `this_coro::token()` awaitable has been superseded by the 468 `asio::use_awaitable` completion token. 469 * Please note that the `use_awaitable` and `redirect_error` completion tokens 470 work only with asynchronous operations that use the new form of 471 `async_result` with member function `initiate`. Furthermore, when using 472 `use_awaitable`, please be aware that the asynchronous operation is not 473 initiated until `co_await` is applied to the `awaitable<>`. 474* Added a new `DynamicBuffer_v2` concept which is CopyConstructible. 475 * This change adds a new set of type requirements for dynamic buffers, 476 `DynamicBuffer_v2`, which supports copy construction. These new type 477 requirements enable dynamic buffers to be used as arguments to 478 user-defined composed operations, where the same dynamic buffer object 479 is used repeatedly for multiple underlying operations. For example:[br] 480 `` 481 template <typename DynamicBuffer> 482 void echo_line(tcp::socket& sock, DynamicBuffer buf) 483 { 484 n = asio::read_until(sock, buf, '\n'); 485 asio::write(sock, buf, asio::transfer_exactly(n)); 486 } 487 ``[br] 488 * The original `DynamicBuffer` type requirements have been renamed to 489 `DynamicBuffer_v1`. These requirements continue to be compatible with the 490 Networking TS. 491 * New type traits `is_dynamic_buffer_v1` and `is_dynamic_buffer_v2` have been 492 added to test for conformance to `DynamicBuffer_v1` and `DynamicBuffer_v2` 493 respectively. The existing `is_dynamic_buffer` trait has been retained and 494 delegates to `is_dynamic_buffer_v1` (unless `BOOST_ASIO_NO_DYNAMIC_BUFFER_V1` is 495 explicitly defined, in which case it delegates to `is_dynamic_buffer_v2`). 496 * For convenience, the `dynamic_string_buffer` and `dynamic_vector_buffer` 497 classes conform to both `DynamicBuffer_v1` and `DynamicBuffer_v2` 498 requirements. 499 * When `BOOST_ASIO_NO_DYNAMIC_BUFFER_V1` is defined, all support for 500 `DynamicBuffer_v1` types and functions is #ifdef-ed out. Support for using 501 `basic_streambuf` with the `read`, `async_read`, `read_until`, 502 `async_read_until`, `write`, and `async_write` functions is also disabled 503 as a consequence. 504 * Note: This change should have no impact on existing source code that simply 505 uses dynamic buffers in conjunction with Asio's composed operations. 506* Added a new `async_compose` function that simplifies the implementation of 507 user-defined asynchronous operations. 508* Added a `make_strand` function, which creates a `strand` with a deduced 509 `Executor` template argument. 510* Relaxed the completion condition type requirements to only require 511 move-constructibility rather than copy-constructibility. 512* Added a constructor for `local::basic_endpoint` that takes a `string_view`. 513* Added the noexcept qualifier to various member functions of the 514 `ip::address`, `ip::address_v4`, `ip::address_v6`, `ip::basic_endpoint`, and 515 `executor_work_guard` classes. 516* Added the noexcept qualifier to the `buffer_sequence_begin` and 517 `buffer_sequence_end` functions. 518* Added a new `BOOST_ASIO_DISABLE_VISIBILITY` configuration `#define` that allows 519 visibility pragmas to be disabled. (Note: If symbols are hidden, extra care 520 must be taken to ensure that Asio types are not passed across shared 521 library API boundaries.) 522* Enabled recycling of the memory used to type-erase a function object with the 523 polymorphic executor. 524* Changed receive operations to return the correct number of bytes transferred 525 when truncation (`error::message_size`) occurs on a datagram-oriented socket. 526* Fixed multicast behaviour on QNX by automatically applying `SO_REUSEPORT` 527 when the `reuse_address` option is set. 528* Added inclusion of `unistd.h` when targeting Haiku OS, to fix feature detection. 529* Added the `network_v[46].hpp` headers to the top-level convenience header. 530* Fixed calculation of absolute timeout when the backend uses 531 `pthread_cond_timedwait`. 532* Changed the range-based asynchronous connect operation to deduce the 533 `EndpointSequence` iterator type rather than assume the presence of a 534 `const_iterator` typedef. 535* Fixed `buffer_sequence_begin` and `buffer_sequence_end` to prevent implicit 536 conversion. This change addresses an issue where a call to 537 `buffer_sequence_begin` or `buffer_sequence_end` could trigger an implicit 538 conversion to `const_buffer` or `mutable_buffer`. Whenever this implicit 539 conversion occurred, the return value of `buffer_sequence_begin` or 540 `buffer_sequence_end` would point to a temporary object. 541* Ensured SSL handshake errors are propagated to the peer before the local 542 operation completes. 543* Suppressed the `eof` error on SSL shutdown as it actually indicates success. 544* Added a fallback error code for when we OpenSSL produces an 545 `SSL_ERROR_SYSCALL` result without an associated error. 546* Changed composed asynchronous read and write operations to move, rather than 547 copy, the buffer sequence objects when the composed operation implementation 548 is moved. 549* Changed to use `<atomic>` when targeting apple/clang/libc++ with recent Xcode 550 versions, even for C++03. This fixes a warning about the deprecation of 551 `OSMemoryBarrier`. 552* Fixed compile errors that occur when using the composed read and write 553 operations with MSVC 11.0, by disabling `decltype` support for that compiler. 554* Increased the default value of `_WIN32_WINNT` to `0x0601` (Windows 7). 555* Fixed `dispatch` documentation to note that it may call the supplied function 556 object in the current thread. 557* Updated `post` and `defer` documentation to clarify the the distinction 558 between them. 559* Fixed compilation errors in the read and write composed operations when used 560 with MSVC 11.0. 561* Fixed a Windows-specific issue where the execution context associated with 562 `system_executor` was not being correctly cleaned up on exit. 563 564[heading Asio 1.12.2 / Boost 1.69] 565 566* Fixed a problem with the detection of `std::future` availability with 567 libstdc++. 568* Fixed compile error in regex overload of `read_until`. 569* Fixed a timer heap corruption issue that can occur when moving a cancelled 570 timer. 571* Fixed detection of `std::experimental::string_view` and `std::string_view` 572 with newer clang/libc++. 573* Fixed MSVC version detection for availability of `std::invoke_result`. 574* Fixed the buffer sequence traits to test the new requirements, if `decltype` 575 is available. 576* Fixed an MSVC issue when building with exceptions disabled. 577* Added SSL context options for TLS v1.3. 578* Added a compile-time test for TLS v1 support. 579* Fixed the macro used to test for TLS v1.2 support. 580* Prevented global objects from being created once per thread on Windows. 581* Fixed a crash when using `size()`, `max_size()` or `empty()` on 582 default-constructed resolver results. 583* Changed to move the return value in basic_resolver_results::begin() to avoid 584 copying. 585* Enabled move support for the Intel Compiler. 586* Fixed `std::string_view` detection issue when using clang-cl. 587* Fixed the handler tracking operation name for 588 `io_context::executor_type::dispatch`. 589* Fixed a buffer overflow that could occur when parsing an address string with 590 a 64-bit scope id. 591* Added examples showing how to write composed operations. 592* Added C++11 versions of the Timeouts, Timers, SOCKS4 and SSL examples. 593* Fixed minor issues in documentation and examples. 594 595[heading Asio 1.12.1 / Boost 1.67] 596 597* Added missing const qualifier to `basic_socket_acceptor::get_option`. 598* Worked around a parsing error that occurs with some versions of gcc. 599* Fixed broken code samples in tutorial. 600* Added new experimental features. (Note that "experimental" features may be 601 changed without notice in subsequent releases.) 602 * Added `experimental::detached` completion token. 603 * Added `experimental::redirect_error` completion token. 604 * Added `experimental::co_spawn` facility for integration with the coroutines 605 technical specification. 606* Updated timeout examples to use latest features. 607 * Used `asio::steady_timer` rather than `asio::deadline_timer`. 608 * Used `asio::dynamic_buffer` rather than `asio::streambuf`. 609 * Used timed `asio::io_context::run_for()` function for blocking clients. 610 * Added example showing a custom completion token for blocking with timeouts. 611* Fixed unit tests to compile when `BOOST_ASIO_NO_DEPRECATED` is defined. 612* Changed socket iostreams to use chrono by default, to fix compatibility with 613 the Networking TS. Define `BOOST_ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM` 614 to enable the old Boost.Date_Time interface in `basic_socket_streambuf` and 615 `basic_socket_iostream`. 616* Updated examples to use chrono rather than Boost.Date_Time. 617* Fixed an incorrect member function detector in the `is_dynamic_buffer` trait. 618* Fixed an `async_result` incompatibility with deprecated `handler_type`. 619* Added a missing move optimisation in the SSL stream implementation. 620* Fixed incorrect `basic_resolver_results::value_type` typedef. 621* Fixed a compile error with some OpenSSL versions when `SSL_OP_NO_COMPRESSION` 622 is defined. 623* Changed `add_certificate_authority` to process multiple certificates in a bundle. 624* Eliminated deprecation warning with MSVC by using `std::invoke_result` rather 625 than `std::result_of`. 626* Changed to use `std::string_view` for C++17 or later, and 627 `std::experimental::string_view` for C++14. Define the preprocessor macro 628 `BOOST_ASIO_DISABLE_STD_STRING_VIEW` to force the use of 629 std::experimental::string_view (assuming it is available) when compiling in 630 C++17 mode. 631* Ensured `DynamicBuffer` template arguments are decayed before using in 632 `enable_if` tests. 633* Changed documentation to distinguish legacy completion handlers (which are 634 still required to be CopyConstructible) from new MoveConstructible handlers. 635* Suppressed a discarded return value warning in the buffer debugging support. 636* Fixed `basic_yield_context` to work with completion signatures containing 637 reference parameters. 638* Ensured that stackful coroutines launched using `spawn()` correctly store 639 decayed copies of their function and handler arguments. 640* Fixed some compatibility issues with Android. 641* Added cross-compilation support to Jamfiles. 642* Fixed some minor portability issues in examples. 643 644[heading Asio 1.12.0 / Boost 1.66] 645 646* Implemented interface changes to reflect the Networking TS 647 ([@www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4656.pdf N4656]). 648 * See the [link boost_asio.net_ts list] of new interfaces and, where 649 applicable, the corresponding old interfaces that have been superseded. 650 * The service template parameters, and the corresponding classes, are disabled 651 by default. For example, instead of `basic_socket<Protocol, SocketService>` we 652 now have simply `basic_socket<Protocol>`. The old interface can be enabled by 653 defining the `BOOST_ASIO_ENABLE_OLD_SERVICES` macro. 654* Removed previously deprecated functions. 655* Added support for customised handler tracking. 656* Added reactor-related (i.e. descriptor readiness) events to handler tracking. 657* Added special [link boost_asio.overview.core.concurrency_hint concurrency 658 hint] values that may be used to disable locking on a per `io_context` basis. 659* Enabled perfect forwarding for the first `ssl::stream<>` constructor argument. 660* Added ability to release ownership of the underlying native socket. (Requires 661 Windows 8.1 or later when using the I/O completion port backend.) 662 663[heading Asio 1.10.10 / Boost 1.65] 664 665* Changed to require [^g++] versions >= 4.7 to use standard atomics, to fix 666 a linker error when using [^g++] 4.6 ([ticket 13121]). 667* Enabled use of `constexpr` and variadic templates with recent MSVC versions. 668* Fixed a race condition in the Linux epoll backend, which may occur when a 669 socket or descriptor is closed while another thread is blocked on epoll. 670* Eliminated use of deprecated `auto_ptr`. 671* Fixed misplaced use of `asio_handler_is_continuation` result in reactive 672 `async_accept` implementation. 673* Changed to use `poll.h` rather than `sys/poll.h` on some modern POSIX 674 platforms ([ticket 12419]). 675* Fixed MSVC intellisense detection. 676* Disabled use of the `__thread` keyword extension for android/clang/x86 677 targets. 678 679[heading Asio 1.10.9 / Boost 1.64] 680 681* Added limited support for using regular file descriptors (where I/O 682 operations should never fail with `EAGAIN` or `EWOULDBLOCK`) with 683 `posix::stream_descriptor`, when using the Linux epoll backend. 684* Changed to use `allocator_traits` to rebind allocators in C++11 or later. 685* Eliminated a double "construction" issue in the converting move constructors. 686* Added new `ssl::context_base` enumerations to enable support for any TLS 687 version, and improved consistency of SSL/TLS version handling across OpenSSL 688 releases. 689* Applied more changes to address OpenSSL 1.1 compatibility. 690* Fixed a compile error when OpenSSL compression is disabled at compile time. 691* Suppressed some spurious unused variable warnings issued by [^gcc] ([ticket 692 12302]). 693* Worked around a new clang warning issued for usage of the comma operator. 694* Fixed various header ordering problems. 695* Changed to refer `std::atomic_thread_fence`, when available, to eliminate a 696 deprecated function warning on newest macOS SDK ([ticket 12482]). 697* Added a workaround for broken `getaddrinfo` in Apple's NAT64 environment. 698* Fixed an exception safety issue in the internal hash map implementation. 699 700[heading Asio 1.10.8 / Boost 1.62] 701 702* Added compatibility with OpenSSL 1.1.0 ([ticket 12238]). 703* Fixed out-of-bounds iterator use in `asio::connect()` when the 704 `connect_condition` returns an end iterator ([ticket 12354]). 705* Added a workaround for a move detection problem on MSVC 2015 Update 2 706 ([ticket 12115]). 707* Changed a workaround that was previously added for broken Windows firewalls 708 to only bind to 127.0.0.1 if `getsockname` reports 0.0.0.0 ([ticket 709 12406]). 710* Added call to `SSL_COMP_free_compression_methods` to fix two memory leaks 711 reported at shutdown, for OpenSSL versions >= 1.0.2 and < 1.1.0 ([ticket 712 10795]). 713* Fixed `use_future` compile error encountered on some standard library 714 implementations, by changing `std::allocator<void>` use to a non-void 715 template parameter. 716* Enabled use of native `getaddrinfo` by default on Apple OSes, rather than 717 emulation in terms of `getipnodebyname`. 718 719[heading Asio 1.10.7 / Boost 1.60] 720 721* Added support for Windows 8.1 Store apps. 722* Fixed macro multiple definition error on Microsoft Visual Studio 2015 723 ([ticket 11539]). 724* Changed Asio's SSL wrapper to respect OpenSSL's `OPENSSL_NO_SSL3` feature 725 test `#define` ([ticket 11754]). 726* Changed Asio's SSL wrapper to use OpenSSL's new `SSL_CTX_clear_chain_certs` 727 function, if available. 728* Suppressed a clang 3.6+ warning about unused typedefs ([ticket 11767]). 729* Regenerated certificates used by SSL examples. 730* Fixed buffer sizes passed to `strncat` in the `getaddrinfo` emulation and in 731 the SSL wrapper's password handling. 732* Changed Windows backend to use non-macro `CreateEventW` rather than 733 `CreateEvent` ([ticket 11732]). 734 735[heading Asio 1.10.6 / Boost 1.58] 736 737* Ensured errors generated by Windows' `ConnectEx` function are mapped to their 738 portable equivalents ([ticket 10744]). 739* Added new macro `BOOST_ASIO_DISABLE_CONNECTEX` to allow use of `ConnectEx` to 740 be explicitly disabled. 741* Fixed a race condition in `windows::object_handle` when there are pending 742 wait operations on destruction ([ticket 10624]). 743* Fixed IPv6 address parsing on FreeBSD, where a trailing scope ID would cause 744 conversion to fail with `EINVAL`. 745* Worked around shared library visibility issues by ensuring Asio types use 746 default visibility ([ticket 9465], [ticket 11070]). 747* Changed the SSL wrapper to call the password callback when loading an 748 in-memory key ([ticket 10828]). 749* Fixed false SSL error reports by ensuring that the SSL error queue is cleared 750 prior to each operation. 751* Fixed an `ssl::stream<>` bug that may result in spurious 'short read' errors. 752* Removed a redundant null pointer check in the SSL engine ([ticket 10088]). 753* Added options for disabling TLS v1.1 and v1.2 ([ticket 10690]). 754* Removed use of deprecated OpenSSL function `ERR_remove_state`. 755* Fixed detection of various C++11 features with Clang ([ticket 8835], 756 [ticket 10884]). 757* Fixed detection of C++11 `std::addressof` with [^g++] ([ticket 10982]). 758* Changed multicast test to treat certain `join_group` failures as non-fatal. 759* Decoupled Asio unit tests from Boost.Test ([ticket 11116]). 760* Changed the tutorial to use `std::endl` to ensure output is flushed. 761* Fixed an unsigned integer overflow reported by Clang's integer sanitizer. 762* Added support for move-only return types when using a `yield_context` object 763 with asynchronous operations. 764* Changed `yield_context` to allow reentrant calls to the completion handler 765 from an initiating function. 766* Updated detection of Windows Runtime to work with latest Windows SDK. 767 768[heading Asio 1.10.5 / Boost 1.57] 769 770* Fixed the [^kqueue] reactor so that it works on FreeBSD ([ticket 10606]). 771* Fixed an issue in the [^kqueue] reactor which resulted in spinning when using 772 serial ports on Mac OS ([ticket 10496]). 773* Fixed [^kqueue] reactor support for read-only file descriptors 774 ([ticket 10367]). 775* Fixed a compile error when using the [^/dev/poll] reactor ([ticket 10350], 776 [ticket 10572]). 777* Changed the Windows backend to use `WSASocketW`, as `WSASocketA` has been 778 deprecated ([ticket 10534]). 779* Fixed some warnings reported by Visual C++ 2013 ([ticket 10376]). 780* Fixed integer type used in the WinRT version of the byte-order conversion 781 functions ([ticket 10539]). 782* Changed documentation to indicate that `use_future` and `spawn()` are not 783 made available when including the `asio.hpp` convenience header ([ticket 784 10567]). 785* Explicitly marked `asio::strand` as deprecated. Use 786 `asio::io_service::strand` instead. 787 788[heading Asio 1.10.4 / Boost 1.56] 789 790* Stopped using certain Winsock functions that are marked as deprecated in the 791 latest Visual C++ and Windows SDK. 792* Fixed a shadow variable warning on Windows. 793* Fixed a regression in the [^kqueue] backend that was introduced in Asio 794 1.10.2. 795* Added a workaround for building the unit tests with [^gcc] on AIX. 796 797[heading Asio 1.10.3] 798 799* Worked around a [^gcc] problem to do with anonymous enums ([ticket 10042]). 800* Reverted the Windows `HANDLE` backend change to ignore `ERROR_MORE_DATA`. 801 Instead, the error will be propagated as with any other (i.e. in an 802 `error_code` or thrown as a `system_error`), and the number of bytes 803 transferred will be returned. For code that needs to handle partial messages, 804 the `error_code` overload should be used ([ticket 10034]). 805* Fixed an off-by-one error in the `signal_set` implementation's signal 806 number check ([ticket 9324]). 807* Changed the Windows IOCP backend to not assume that 808 `SO_UPDATE_CONNECT_CONTEXT` is defined ([ticket 10016]). 809* Fixed a Windows-specific issue, introduced in Asio 1.10.2, by using 810 `VerifyVersionInfo` rather than `GetVersionEx`, as `GetVersionEx` has been 811 deprecated. 812* Changed to use SSE2 intrinsics rather than inline assembly, to allow the 813 Cray compiler to work. 814 815[heading Asio 1.10.2] 816 817* Fixed `asio::spawn()` to work correctly with new Boost.Coroutine interface 818 ([ticket 9442], [ticket 9928]). 819* Ensured that incomplete `asio::spawn()` coroutines are correctly unwound when 820 cleaned up by the `io_service` destructor ([ticket 9731]). 821* Fixed delegation of continuation hook for handlers produced by 822 `io_service::wrap()` and `strand::wrap()` ([ticket 9741]). 823* Changed the Windows I/O completion port backend to use `ConnectEx`, if 824 available, for connection-oriented IP sockets. 825* Changed the `io_service` backend for non-Windows (and non-IOCP Windows) 826 platforms to use a single condition variable per `io_service` instance. 827 This addresses a potential race condition when `run_one()` is used from 828 multiple threads. 829* Prevented integer overflow when computing timeouts based on some 830 `boost::chrono` and `std::chrono` clocks ([ticket 9662], [ticket 9778]). 831* Made further changes to `EV_CLEAR` handling in the kqueue backend, to address 832 other cases where the `close()` system call may hang on Mac OS X. 833* Fixed infinite recursion in implementation of 834 `resolver_query_base::flags::operator~` ([ticket 9548]). 835* Made the `select` reactor more efficient on Windows for large numbers of 836 sockets ([ticket 9528]). 837* Fixed a Windows-specific type-aliasing issue reported by [^gcc] ([ticket 838 9550]). 839* Prevented execution of compile-time-only buffer test to avoid triggering an 840 address sanitiser warning ([ticket 8295]). 841* Disabled the `GetQueuedCompletionStatus` timeout workaround on recent 842 versions of Windows. 843* Added support for string-based scope IDs when using link-local multicast 844 addresses. 845* Changed IPv6 multicast group join to use the address's scope ID as the 846 interface, if an interface is not explicitly specified. 847* Fixed multicast test failure on Mac OS X and the BSDs by using a link-local 848 multicast address. 849* Various minor documentation improvements ([ticket 8295], [ticket 9605], 850 [ticket 9771]). 851 852[heading Asio 1.10.1 / Boost 1.55] 853 854* Implemented a limited port to Windows Runtime. This support requires that the 855 language extensions be enabled. Due to the restricted facilities exposed by 856 the Windows Runtime API, the port also comes with the following caveats: 857 * The core facilities such as the `io_service`, `strand`, buffers, composed 858 operations, timers, etc., should all work as normal. 859 * For sockets, only client-side TCP is supported. 860 * Explicit binding of a client-side TCP socket is not supported. 861 * The `cancel()` function is not supported for sockets. Asynchronous 862 operations may only be cancelled by closing the socket. 863 * Operations that use `null_buffers` are not supported. 864 * Only `tcp::no_delay` and `socket_base::keep_alive` options are supported. 865 * Resolvers do not support service names, only numbers. I.e. you must 866 use "80" rather than "http". 867 * Most resolver query flags have no effect. 868* Fixed a regression (introduced in Boost 1.54) where, on some platforms, errors 869 from `async_connect` were not correctly propagated through to the completion 870 handler ([ticket 8795]). 871* Fixed a Windows-specific regression (introduced in Boost 1.54) that occurs 872 when multiple threads are running an `io_service`. When the bug occurs, the 873 result of an asynchronous operation (error and bytes tranferred) is 874 incorrectly discarded and zero values used instead. For TCP sockets this 875 results in spurious end-of-file notifications ([ticket 8933]). 876* Fixed a bug in handler tracking, where it was not correctly printing out some 877 handler IDs ([ticket 8808]). 878* Fixed the comparison used to test for successful synchronous accept 879 operations so that it works correctly with unsigned socket descriptors 880 ([ticket 8752]). 881* Ensured the signal number is correctly passed to the completion handler when 882 starting an `async_wait` on a signal that is already raised ([ticket 8738]). 883* Suppressed a g++ 4.8+ warning about unused typedefs ([ticket 8980]). 884* Enabled the move optimisation for handlers that use the default invocation 885 hook ([ticket 8624]). 886* Clarified that programs must not issue overlapping `async_write_at` 887 operations ([ticket 8669]). 888* Changed the Windows `HANDLE` backend to treat `ERROR_MORE_DATA` as a 889 non-fatal error when returned by `GetOverlappedResult` for a synchronous 890 read ([ticket 8722]). 891* Visual C++ language extensions use `generic` as a keyword. Added a 892 workaround that renames the namespace to `cpp_generic` when those language 893 extensions are in effect. 894* Fixed some asynchronous operations that missed out on getting `async_result` 895 support in Boost 1.54. In particular, the buffered stream templates have been 896 updated so that they adhere to current handler patterns ([ticket 9000], 897 [ticket 9001]). 898* Enabled move support for Microsoft Visual Studio 2012 ([ticket 8959]). 899* Added `use_future` support for Microsoft Visual Studio 2012. 900* Removed a use of `std::min` in the Windows IOCP backend to avoid a 901 dependency on the `<algorithm>` header ([ticket 8758]). 902* Eliminated some unnecessary handler copies. 903* Fixed support for older versions of OpenSSL that do not provide the 904 `SSL_CTX_clear_options` function ([ticket 9273]). 905* Fixed various minor and cosmetic issues in code and documentation 906 (including [ticket 8347], [ticket 8950], [ticket 8953], [ticket 8965], 907 [ticket 8997], [ticket 9230]). 908 909[heading Asio 1.10.0 / Boost 1.54] 910 911* Added new traits classes, `handler_type` and `async_result`, that allow the 912 customisation of the return type of an initiating function. 913* Added the `asio::spawn()` function, a high-level wrapper for running 914 stackful coroutines, based on the Boost.Coroutine library. The `spawn()` 915 function enables programs to implement asynchronous logic in a synchronous 916 manner. For example: `size_t n = my_socket.async_read_some(my_buffer, yield);`. 917 For further information, see [link boost_asio.overview.core.spawn Stackful 918 Coroutines]. 919* Added the `asio::use_future` special value, which provides first-class 920 support for returning a C++11 `std::future` from an asynchronous 921 operation's initiating function. For example: 922 `future<size_t> = my_socket.async_read_some(my_buffer, asio::use_future);`. 923 For further information, see [link boost_asio.overview.cpp2011.futures C++ 924 2011 Support - Futures]. 925* Promoted the stackless coroutine class and macros to be part of Asio's 926 documented interface, rather than part of the HTTP server 4 example. 927 For further information, see [link boost_asio.overview.core.coroutine 928 Stackless Coroutines]. 929* Added a new handler hook called `asio_handler_is_continuation`. 930 Asynchronous operations may represent a continuation of the asynchronous 931 control flow associated with the current executing handler. The 932 `asio_handler_is_continuation` hook can be customised to return `true` if 933 this is the case, and Asio's implementation can use this knowledge to 934 optimise scheduling of the new handler. To cover common cases, Asio 935 customises the hook for strands, `spawn()` and composed asynchronous 936 operations. 937* Added four new generic protocol classes, `generic::datagram_protocol`, 938 `generic::raw_protocol`, `generic::seq_packet_protocol` and 939 `generic::stream_protocol`, which implement the `Protocol` type 940 requirements, but allow the user to specify the address family (e.g. 941 `AF_INET`) and protocol type (e.g. `IPPROTO_TCP`) at runtime. 942 For further information, see [link 943 boost_asio.overview.networking.other_protocols Support for Other Protocols]. 944* Added C++11 move constructors that allow the conversion of a socket (or 945 acceptor) into a more generic type. For example, an `ip::tcp::socket` can 946 be converted into a `generic::stream_protocol::socket` via move 947 construction. 948 For further information, see [link 949 boost_asio.overview.networking.other_protocols Support for Other Protocols]. 950* Extended the `basic_socket_acceptor<>`'s `accept()` and `async_accept()` 951 functions to allow a new connection to be accepted directly into a socket 952 of a more generic type. For example, an `ip::tcp::acceptor` can be used to 953 accept into a `generic::stream_protocol::socket` object. 954 For further information, see [link 955 boost_asio.overview.networking.other_protocols Support for Other Protocols]. 956* Moved existing examples into a C++03-specific directory, and added a new 957 directory for C++11-specific examples. A limited subset of the C++03 958 examples have been converted to their C++11 equivalents. 959* Various SSL enhancements. Thanks go to Nick Jones, on whose work these changes 960 are based. 961 * Added support for SSL handshakes with re-use of data already read from 962 the wire. New overloads of the `ssl::stream<>` class's `handshake()` and 963 `async_handshake()` functions have been added. These accept a 964 `ConstBufferSequence` to be used as initial input to the ssl engine for 965 the handshake procedure. 966 * Added support for creation of TLSv1.1 and TLSv1.2 `ssl::context` objects. 967 * Added a `set_verify_depth()` function to the `ssl::context` and 968 `ssl::stream<>` classes. 969 * Added the ability to load SSL certificate and key data from memory 970 buffers. New functions, `add_certificate_authority()`, 971 `use_certificate()`, `use_certificate_chain()`, `use_private_key()`, 972 `use_rsa_private_key()` and `use_tmp_dh()`, have been added to the 973 `ssl::context` class. 974 * Changed `ssl::context` to automatically disable SSL compression by 975 default. To enable, use the new `ssl::context::clear_options()` function, 976 as in `my_context.clear_options(ssl::context::no_compression)`. 977* Fixed a potential deadlock in `signal_set` implementation. 978* Fixed an error in acceptor example in documentation [ticket 8421]. 979* Fixed copy-paste errors in waitable timer documentation [ticket 8602]. 980* Added assertions to satisfy some code analysis tools [ticket 7739]. 981* Fixed a malformed `#warning` directive [ticket 7939]. 982* Fixed a potential data race in the Linux `epoll` implementation. 983* Fixed a Windows-specific bug, where certain operations might generate an 984 `error_code` with an invalid (i.e. `NULL`) `error_category` [ticket 8613]. 985* Fixed `basic_waitable_timer`'s underlying implementation so that it can 986 handle any `time_point` value without overflowing the intermediate duration 987 objects. 988* Fixed a problem with lost thread wakeups that can occur when making 989 concurrent calls to `run()` and `poll()` on the same `io_service` object 990 [ticket 8354]. 991* Fixed implementation of asynchronous connect operation so that it can cope 992 with spurious readiness notifications from the reactor [ticket 7961]. 993* Fixed a memory leak in the `ssl::rfc2818_verification` class. 994* Added a mechanism for disabling automatic Winsock initialisation [ticket 995 3605]. See the header file [^boost/asio/detail/winsock_init.hpp] for details. 996 997[heading Asio 1.8.3 / Boost 1.53] 998 999* Fixed some 64-to-32-bit conversion warnings ([ticket 7459]). 1000* Fixed some small errors in documentation and comments ([ticket 7761]). 1001* Fixed an error in the example embedded in `basic_socket::get_option`'s 1002 documentation ([ticket 7562]). 1003* Changed to use `long` rather than `int` for SSL_CTX options, to match OpenSSL 1004 ([ticket 7209]). 1005* Changed to use `_snwprintf` to address a compile error due to the changed 1006 `swprintf` signature in recent versions of MinGW ([ticket 7373]). 1007* Fixed a deadlock that can occur on Windows when shutting down a pool of 1008 `io_service` threads due to running out of work ([ticket 7552]). 1009* Enabled the `noexcept` qualifier for error categories ([ticket 7797]). 1010* Changed UNIX domain socket example to treat errors from `accept` as non-fatal 1011 ([ticket 7488]). 1012* Added a small block recycling optimisation to improve default memory 1013 allocation behaviour. 1014 1015[heading Asio 1.8.2 / Boost 1.51] 1016 1017* Fixed an incompatibility between `ip::tcp::iostream` and C++11 1018 ([@https://svn.boost.org/trac/boost/ticket/7162 #7162]). 1019* Decorated GCC attribute names with underscores to prevent interaction 1020 with user-defined macros 1021 ([@https://svn.boost.org/trac/boost/ticket/6415 #6415]). 1022* Added missing `#include <cctype>`, needed for some versions of MinGW. 1023* Changed to use [^gcc]'s atomic builtins on ARM CPUs, when available 1024 ([@https://svn.boost.org/trac/boost/ticket/7140 #7140]). 1025* Changed strand destruction to be a no-op, to allow strand objects to be 1026 destroyed after their associated `io_service` has been destroyed. 1027* Added support for some newer versions of glibc which provide the 1028 `epoll_create1()` function but always fail with `ENOSYS` 1029 ([@https://svn.boost.org/trac/boost/ticket/7012 #7012]). 1030* Changed the SSL implementation to throw an exception if SSL engine 1031 initialisation fails 1032 ([@https://svn.boost.org/trac/boost/ticket/6303 #6303]). 1033* Fixed another regression in `buffered_write_stream` 1034 ([@https://svn.boost.org/trac/boost/ticket/6310 #6310]). 1035* Implemented various minor performance improvements, primarily targeted at 1036 Linux x86 and x86-64 platforms. 1037 1038[heading Asio 1.8.1 / Boost 1.50] 1039 1040* Changed the `epoll_reactor` backend to do lazy registration for `EPOLLOUT` 1041 events. 1042* Fixed the `epoll_reactor` handling of out-of-band data, which was broken by 1043 an incomplete fix in the last release. 1044* Changed Asio's SSL wrapper to respect OpenSSL's `OPENSSL_NO_ENGINE` feature 1045 test `#define` ([@https://svn.boost.org/trac/boost/ticket/6432 #6432]). 1046* Fixed `windows::object_handle` so that it works with Windows compilers that 1047 support C++11 move semantics (such as [^g++]). 1048* Improved the performance of strand rescheduling. 1049* Added support for [^g++] 4.7 when compiling in C++11 mode 1050 ([@https://svn.boost.org/trac/boost/ticket/6620 #6620]). 1051* Fixed a problem where `signal_set` handlers were not being delivered when 1052 the `io_service` was constructed with a `concurrency_hint` of 1 1053 ([@https://svn.boost.org/trac/boost/ticket/6657 #6657]). 1054 1055[heading Asio 1.8.0 / Boost 1.49] 1056 1057* Added a new class template `basic_waitable_timer` based around the C++11 clock 1058 type requirements. It may be used with the clocks from the C++11 `<chrono>` 1059 library facility or, if those are not available, Boost.Chrono. The typedefs 1060 `high_resolution_timer`, `steady_timer` and `system_timer` may be used to 1061 create timer objects for the standard clock types. 1062* Added a new `windows::object_handle` class for performing waits on Windows 1063 kernel objects. Thanks go to Boris Schaeling for contributing substantially 1064 to the development of this feature. 1065* On Linux, `connect()` can return EAGAIN in certain circumstances. Remapped 1066 this to another error so that it doesn't look like a non-blocking operation 1067 ([@https://svn.boost.org/trac/boost/ticket/6048 #6048]). 1068* Fixed a compile error on NetBSD 1069 ([@https://svn.boost.org/trac/boost/ticket/6098 #6098]). 1070* Fixed deadlock on Mac OS X 1071 ([@https://svn.boost.org/trac/boost/ticket/6275 #6275]). 1072* Fixed a regression in `buffered_write_stream` 1073 ([@https://svn.boost.org/trac/boost/ticket/6310 #6310]). 1074* Fixed a non-paged pool "leak" on Windows when an `io_service` is repeatedly 1075 run without anything to do 1076 ([@https://svn.boost.org/trac/boost/ticket/6321 #6321]). 1077* Reverted earlier change to allow some speculative operations to be performed 1078 without holding the lock, as it introduced a race condition in some 1079 multithreaded scenarios. 1080* Fixed a bug where the second buffer in an array of two buffers may be ignored 1081 if the first buffer is empty. 1082 1083[heading Asio 1.6.1 / Boost 1.48] 1084 1085* Implemented various performance improvements, including: 1086 * Using thread-local operation queues in single-threaded use cases (i.e. when 1087 `concurrency_hint` is 1) to eliminate a lock/unlock pair. 1088 * Allowing some `epoll_reactor` speculative operations to be performed 1089 without holding the lock. 1090 * Improving locality of reference by performing an `epoll_reactor`'s I/O 1091 operation immediately before the corresponding handler is called. This also 1092 improves scalability across CPUs when multiple threads are running the 1093 `io_service`. 1094 * Specialising asynchronous read and write operations for buffer sequences 1095 that are arrays (`boost::array` or `std::array`) of exactly two buffers. 1096* Fixed a compile error in the regex overload of `async_read_until` 1097 ([@https://svn.boost.org/trac/boost/ticket/5688 #5688]). 1098* Fixed a Windows-specific compile error by explicitly specifying the 1099 `signal()` function from the global namespace 1100 ([@https://svn.boost.org/trac/boost/ticket/5722 #5722]). 1101* Changed the `deadline_timer` implementation so that it does not read the 1102 clock unless the timer heap is non-empty. 1103* Changed the SSL stream's buffers' sizes so that they are large enough to hold 1104 a complete TLS record ([@https://svn.boost.org/trac/boost/ticket/5854 #5854]). 1105* Fixed the behaviour of the synchronous `null_buffers` operations so that they 1106 obey the user's non-blocking setting 1107 ([@https://svn.boost.org/trac/boost/ticket/5756 #5756]). 1108* Changed to set the size of the select `fd_set` at runtime when using Windows. 1109* Disabled an MSVC warning due to const qualifier being applied to function type. 1110* Fixed a crash that occurs when using the Intel C++ compiler 1111 ([@https://svn.boost.org/trac/boost/ticket/5763 #5763]). 1112* Changed the initialisation of the OpenSSL library so that it supports all 1113 available algorithms. 1114* Fixed the SSL error mapping used when the session is gracefully shut down. 1115* Added some latency test programs. 1116* Clarified that a read operation ends when the buffer is full 1117 ([@https://svn.boost.org/trac/boost/ticket/5999 #5999]). 1118* Fixed an exception safety issue in `epoll_reactor` initialisation 1119 ([@https://svn.boost.org/trac/boost/ticket/6006 #6006]). 1120* Made the number of strand implementations configurable by defining 1121 `BOOST_ASIO_STRAND_IMPLEMENTATIONS` to the desired number. 1122* Added support for a new `BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION` flag 1123 which switches the allocation of strand implementations to use a round-robin 1124 approach rather than hashing. 1125* Fixed potential strand starvation issue that can occur when `strand.post()` 1126 is used. 1127 1128[heading Asio 1.6.0 / Boost 1.47] 1129 1130* Added support for signal handling, using a new class called `signal_set`. 1131 Programs may add one or more signals to the set, and then perform an 1132 `async_wait()` operation. The specified handler will be called when one of 1133 the signals occurs. The same signal number may be registered with multiple 1134 `signal_set` objects, however the signal number must be used only with Asio. 1135 Addresses [@https://svn.boost.org/trac/boost/ticket/2879 #2879]. 1136* Added handler tracking, a new debugging aid. When enabled by defining 1137 `BOOST_ASIO_ENABLE_HANDLER_TRACKING`, Asio writes debugging output to the 1138 standard error stream. The output records asynchronous operations and the 1139 relationships between their handlers. It may be post-processed using the 1140 included [^handlerviz.pl] tool to create a visual representation of the 1141 handlers (requires GraphViz). 1142* Added support for timeouts on socket iostreams, such as `ip::tcp::iostream`. 1143 A timeout is set by calling `expires_at()` or `expires_from_now()` to 1144 establish a deadline. Any socket operations which occur past the deadline 1145 will put the iostream into a bad state. 1146* Added a new `error()` member function to socket iostreams, for retrieving the 1147 error code from the most recent system call. 1148* Added a new `basic_deadline_timer::cancel_one()` function. This function lets 1149 you cancel a single waiting handler on a timer. Handlers are cancelled in 1150 FIFO order. 1151* Added a new `transfer_exactly()` completion condition. This can be used to 1152 send or receive a specified number of bytes even if the total size of the 1153 buffer (or buffer sequence) is larger. 1154* Added new free functions `connect()` and `async_connect()`. These operations 1155 try each endpoint in a list until the socket is successfully connected, and 1156 are useful for creating TCP clients that work with both IPv4 and IPv6. 1157* Extended the `buffer_size()` function so that it works for buffer sequences 1158 in addition to individual buffers. 1159* Added a new `buffer_copy()` function that can be used to copy the raw bytes 1160 between individual buffers and buffer sequences. 1161* Added new non-throwing overloads of `read()`, `read_at()`, `write()` and 1162 `write_at()` that do not require a completion condition. 1163* Added friendlier compiler errors for when a completion handler does not meet 1164 the necessary type requirements. When C++0x is available (currently supported 1165 for [^g++] 4.5 or later, and MSVC 10), `static_assert` is also used to 1166 generate an informative error message. This checking may be disabled by 1167 defining `BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS`. 1168* Added a new, completely rewritten SSL implementation. The new implementation 1169 compiles faster, shows substantially improved performance, and supports 1170 custom memory allocation and handler invocation. It includes new API features 1171 such as certificate verification callbacks and has improved error reporting. 1172 The new implementation is source-compatible with the old for most uses. 1173 However, if necessary, the old implementation may still be used by defining 1174 `BOOST_ASIO_ENABLE_OLD_SSL`. 1175 Addresses [@https://svn.boost.org/trac/boost/ticket/3702 #3702], 1176 [@https://svn.boost.org/trac/boost/ticket/3958 #3958]. 1177* Changed the separate compilation support such that, to use Asio's SSL 1178 capabilities, you should also include `boost/asio/ssl/impl/src.hpp` in one 1179 source file in your program. 1180* Changed the SSL implementation to support build environments where SSL v2 is 1181 explicitly disabled ([@https://svn.boost.org/trac/boost/ticket/5453 #5453]). 1182* Made the `is_loopback()`, `is_unspecified()` and `is_multicast()` functions 1183 consistently available across the `ip::address`, `ip::address_v4` and 1184 `ip::address_v6` classes 1185 ([@https://svn.boost.org/trac/boost/ticket/3939 #3939]). 1186* Added new `non_blocking()` functions for managing the non-blocking behaviour 1187 of a socket or descriptor. The `io_control()` commands named `non_blocking_io` 1188 are now deprecated in favour of these new functions. 1189* Added new `native_non_blocking()` functions for managing the non-blocking 1190 mode of the underlying socket or descriptor. These functions are intended to 1191 allow the encapsulation of arbitrary non-blocking system calls as 1192 asynchronous operations, in a way that is transparent to the user of the 1193 socket object. The functions have no effect on the behaviour of the 1194 synchronous operations of the socket or descriptor. 1195* Added the `io_control()` member function for socket acceptors 1196 ([@https://svn.boost.org/trac/boost/ticket/3297 #3297]). 1197* Added a `release()` member function to posix descriptors. This function 1198 releases ownership of the underlying native descriptor to the caller. 1199 Addresses [@https://svn.boost.org/trac/boost/ticket/3900 #3900]. 1200* Added support for sequenced packet sockets (`SOCK_SEQPACKET`). 1201* Added a new `io_service::stopped()` function that can be used to determine 1202 whether the `io_service` has stopped (i.e. a `reset()` call is needed prior 1203 to any further calls to `run()`, `run_one()`, `poll()` or `poll_one()`). 1204* For consistency with the C++0x standard library, deprecated the `native_type` 1205 typedefs in favour of `native_handle_type`, and the `native()` member 1206 functions in favour of `native_handle()`. 1207* Added support for C++0x move construction and assignment to sockets, serial 1208 ports, POSIX descriptors and Windows handles. 1209* Reduced the copying of handler function objects. 1210* Added support for C++0x move construction to further reduce (and in some 1211 cases eliminate) copying of handler objects. 1212* Added support for the `fork()` system call. Programs that use `fork()` must 1213 call `io_service.notify_fork()` at the appropriate times. Two new examples 1214 have been added showing how to use this feature. Addresses 1215 [@https://svn.boost.org/trac/boost/ticket/3238 #3238], 1216 [@https://svn.boost.org/trac/boost/ticket/4162 #4162]. 1217* Cleaned up the handling of errors reported by the `close()` system call. In 1218 particular, assume that most operating systems won't have `close()` fail with 1219 `EWOULDBLOCK`, but if it does then set the blocking mode and restart the call. 1220 If any other error occurs, assume the descriptor is closed. Addresses 1221 [@https://svn.boost.org/trac/boost/ticket/3307 #3307]. 1222* Added new `asio::buffer()` overloads for `std::array`, when available. 1223* Changed the implementation to use the C++0x standard library templates 1224 `array`, `shared_ptr`, `weak_ptr` and `atomic` when they are available, 1225 rather than the Boost equivalents. 1226* Use C++0x variadic templates when available, rather than generating function 1227 overloads using Boost.Preprocessor. 1228* Changed exception reporting to include the function name in exception `what()` 1229 messages. 1230* Fixed insufficient initialisers warning with MinGW. 1231* Changed the `shutdown_service()` member functions to be private. 1232* Added archetypes for testing socket option functions. 1233* Changed the Boost.Asio examples so that they don't use Boost.Thread's 1234 convenience header. Use the header file that is specifically for the 1235 boost::thread class instead. 1236* Removed the dependency on OS-provided macros for the well-known IPv4 and IPv6 1237 addresses. This should eliminate annoying "missing braces around initializer" 1238 warnings ([@https://svn.boost.org/trac/boost/ticket/3741 #3741]). 1239* Reduced the size of `ip::basic_endpoint<>` objects (such as 1240 `ip::tcp::endpoint` and `ip::udp::endpoint`). 1241* Changed the reactor backends to assume that any descriptors or sockets added 1242 using `assign()` may have been `dup()`-ed, and so require explicit 1243 deregistration from the reactor 1244 ([@https://svn.boost.org/trac/boost/ticket/4971 #4971]). 1245* Removed the deprecated member functions named `io_service()`. The 1246 `get_io_service()` member functions should be used instead. 1247* Removed the deprecated typedefs `resolver_query` and `resolver_iterator` from 1248 the `ip::tcp`, `ip::udp` and `ip::icmp` classes. 1249* Modified the `buffers_iterator<>` and `ip::basic_resolver_iterator` classes 1250 so that the value_type typedefs are non-const byte types. 1251* Fixed warnings reported by g++'s [^-Wshadow] compiler option 1252 ([@https://svn.boost.org/trac/boost/ticket/3905 #3905]). 1253* Added an explicit cast to convert the `FIONBIO` constant to int, to suppress 1254 a compiler warning on some platforms 1255 ([@https://svn.boost.org/trac/boost/ticket/5128 #5128]). 1256* Changed most examples to treat a failure by an accept operation as non-fatal 1257 ([@https://svn.boost.org/trac/boost/ticket/5124 #5124]). 1258* Fixed an error in the [^tick_count_timer] example by making the duration type 1259 signed. Previously, a wait on an already-passed deadline would not return for 1260 a very long time ([@https://svn.boost.org/trac/boost/ticket/5418 #5418]). 1261 1262[heading Asio 1.4.9 / Boost 1.46.1] 1263 1264* `EV_ONESHOT` seems to cause problems on some versions of Mac OS X, with the 1265 `io_service` destructor getting stuck inside the `close()` system call. 1266 Changed the kqueue backend to use `EV_CLEAR` instead 1267 ([@https://svn.boost.org/trac/boost/ticket/5021 #5021]). 1268* Fixed compile failures with some versions of [^g++] due to the use of 1269 anonymous enums ([@https://svn.boost.org/trac/boost/ticket/4883 #4883]). 1270* Fixed a bug on kqueue-based platforms, where some system calls that 1271 repeatedly fail with `EWOULDBLOCK` are not correctly re-registered with 1272 kqueue. 1273* Changed `asio::streambuf` to ensure that its internal pointers are updated 1274 correctly after the data has been modified using `std::streambuf` member 1275 functions. 1276* Fixed a bug that prevented the linger socket option from working on platforms 1277 other than Windows. 1278 1279[heading Asio 1.4.8 / Boost 1.46] 1280 1281* Fixed an integer overflow problem that occurs when 1282 `ip::address_v4::broadcast()` is used on 64-bit platforms. 1283* Fixed a problem on older Linux kernels (where epoll is used without timerfd 1284 support) that prevents timely delivery of deadline_timer handlers, after the 1285 program has been running for some time 1286 ([@https://svn.boost.org/trac/boost/ticket/5045 #5045]). 1287 1288[heading Asio 1.4.7 / Boost 1.45] 1289 1290* Fixed a problem on kqueue-based platforms where a `deadline_timer` may 1291 never fire if the `io_service` is running in a background thread 1292 ([@https://svn.boost.org/trac/boost/ticket/4568 #4568]). 1293* Fixed a const-correctness issue that prevented valid uses of 1294 `has_service<>` from compiling 1295 ([@https://svn.boost.org/trac/boost/ticket/4638 #4638]). 1296* Fixed MinGW cross-compilation 1297 ([@https://svn.boost.org/trac/boost/ticket/4491 #4491]). 1298* Removed dependency on deprecated Boost.System functions 1299 ([@https://svn.boost.org/trac/boost/ticket/4672 #4672]). 1300* Ensured `close()`\/`closesocket()` failures are correctly propagated 1301 ([@https://svn.boost.org/trac/boost/ticket/4573 #4573]). 1302* Added a check for errors returned by `InitializeCriticalSectionAndSpinCount` 1303 ([@https://svn.boost.org/trac/boost/ticket/4574 #4574]). 1304* Added support for hardware flow control on QNX 1305 ([@https://svn.boost.org/trac/boost/ticket/4625 #4625]). 1306* Always use `pselect()` on HP-UX, if it is available 1307 ([@https://svn.boost.org/trac/boost/ticket/4578 #4578]). 1308* Ensured handler arguments are passed as lvalues 1309 ([@https://svn.boost.org/trac/boost/ticket/4744 #4744]). 1310* Fixed Windows build when thread support is disabled 1311 ([@https://svn.boost.org/trac/boost/ticket/4680 #4680]). 1312* Fixed a Windows-specific problem where `deadline_timer` objects with expiry 1313 times set more than 5 minutes in the future may never expire 1314 ([@https://svn.boost.org/trac/boost/ticket/4745 #4745]). 1315* Fixed the `resolver` backend on BSD platforms so that an empty service name 1316 resolves to port number `0`, as per the documentation 1317 ([@https://svn.boost.org/trac/boost/ticket/4690 #4690]). 1318* Fixed read operations so that they do not accept buffer sequences of type 1319 `const_buffers_1` ([@https://svn.boost.org/trac/boost/ticket/4746 #4746]). 1320* Redefined `Protocol` and `id` to avoid clashing with Objective-C++ keywords 1321 ([@https://svn.boost.org/trac/boost/ticket/4191 #4191]). 1322* Fixed a `vector` reallocation performance issue that can occur when there are 1323 many active `deadline_timer` objects 1324 ([@https://svn.boost.org/trac/boost/ticket/4780 #4780]). 1325* Fixed the kqueue backend so that it compiles on NetBSD 1326 ([@https://svn.boost.org/trac/boost/ticket/4662 #4662]). 1327* Fixed the socket `io_control()` implementation on 64-bit Mac OS X and BSD 1328 platforms ([@https://svn.boost.org/trac/boost/ticket/4782 #4782]). 1329* Fixed a Windows-specific problem where failures from `accept()` are 1330 incorrectly treated as successes 1331 ([@https://svn.boost.org/trac/boost/ticket/4859 #4859]). 1332* Deprecated the separate compilation header `<boost/asio/impl/src.cpp>` in 1333 favour of `<boost/asio/impl/src.hpp>` 1334 ([@https://svn.boost.org/trac/boost/ticket/4560 #4560]). 1335 1336[heading Asio 1.4.6 / Boost 1.44] 1337 1338* Reduced compile times. (Note that some programs may need to add additional 1339 `#include`s, e.g. if the program uses `boost::array` but does not explicitly 1340 include `<boost/array.hpp>`.) 1341* Reduced the size of generated code. 1342* Refactored `deadline_timer` implementation to improve performance. 1343* Improved multiprocessor scalability on Windows by using a dedicated hidden 1344 thread to wait for timers. 1345* Improved performance of `asio::streambuf` with `async_read()` and 1346 `async_read_until()`. These read operations now use the existing capacity of 1347 the `streambuf` when reading, rather than limiting the read to 512 bytes. 1348* Added optional separate compilation. To enable, add 1349 `#include <boost/asio/impl/src.cpp>` to one source file in a program, then 1350 build the program with `BOOST_ASIO_SEPARATE_COMPILATION` defined in the 1351 project\/compiler settings. Alternatively, `BOOST_ASIO_DYN_LINK` may be 1352 defined to build a separately-compiled Asio as part of a shared library. 1353* Added new macro `BOOST_ASIO_DISABLE_FENCED_BLOCK` to permit the disabling of 1354 memory fences around completion handlers, even if thread support is enabled. 1355* Reworked timeout examples to better illustrate typical use cases. 1356* Ensured that handler arguments are passed as `const` types. 1357* Fixed incorrect parameter order in `null_buffers` variant of `async_send_to` 1358 ([@https://svn.boost.org/trac/boost/ticket/4170 #4170]). 1359* Ensured `unsigned char` is used with `isdigit` in `getaddrinfo` emulation 1360 ([@https://svn.boost.org/trac/boost/ticket/4201 #4201]). 1361* Fixed handling of very small but non-zero timeouts 1362 ([@https://svn.boost.org/trac/boost/ticket/4205 #4205]). 1363* Fixed crash that occurred when an empty buffer sequence was passed to a 1364 composed read or write operation. 1365* Added missing `operator+` overload in `buffers_iterator` 1366 ([@https://svn.boost.org/trac/boost/ticket/4382 #4382]). 1367* Implemented cancellation of `null_buffers` operations on Windows. 1368 1369[heading Asio 1.4.5 / Boost 1.43] 1370 1371* Improved performance. 1372* Reduced compile times. 1373* Reduced the size of generated code. 1374* Extended the guarantee that background threads don't call user code to all 1375 asynchronous operations 1376 ([@https://svn.boost.org/trac/boost/ticket/3923 #3923]). 1377* Changed to use edge-triggered epoll on Linux. 1378* Changed to use `timerfd` for dispatching timers on Linux, when available. 1379* Changed to use one-shot notifications with kqueue on Mac OS X and BSD 1380 platforms. 1381* Added a bitmask type `ip::resolver_query_base::flags` as per the TR2 proposal. 1382 This type prevents implicit conversion from `int` to `flags`, allowing the 1383 compiler to catch cases where users incorrectly pass a numeric port number as 1384 the service name. 1385* Added `#define NOMINMAX` for all Windows compilers. Users can define 1386 `BOOST_ASIO_NO_NOMINMAX` to suppress this definition 1387 ([@https://svn.boost.org/trac/boost/ticket/3901 #3901]). 1388* Fixed a bug where 0-byte asynchronous reads were incorrectly passing an 1389 `error::eof` result to the completion handler 1390 ([@https://svn.boost.org/trac/boost/ticket/4023 #4023]). 1391* Changed the `io_control()` member functions to always call `ioctl` on the 1392 underlying descriptor when modifying blocking mode 1393 ([@https://svn.boost.org/trac/boost/ticket/3307 #3307]). 1394* Changed the resolver implementation to longer require the typedefs 1395 `InternetProtocol::resolver_query` and `InternetProtocol::resolver_iterator`, 1396 as neither typedef is part of the documented `InternetProtocol` requirements. 1397 The corresponding typedefs in the `ip::tcp`, `ip::udp` and `ip::icmp` classes 1398 have been deprecated. 1399* Fixed out-of-band handling for reactors not based on `select()`. 1400* Added new `BOOST_ASIO_DISABLE_THREADS` macro that allows Asio's threading 1401 support to be independently disabled. 1402* Minor documentation improvements. 1403 1404[heading Asio 1.4.4 / Boost 1.42] 1405 1406* Added a new HTTP Server 4 example illustrating the use of stackless coroutines 1407 with Asio. 1408* Changed handler allocation and invocation to use `boost::addressof` to get the 1409 address of handler objects, rather than applying `operator&` directly 1410 ([@https://svn.boost.org/trac/boost/ticket/2977 #2977]). 1411* Restricted MSVC buffer debugging workaround to 2008, as it causes a crash with 1412 2010 beta 2 ([@https://svn.boost.org/trac/boost/ticket/3796 #3796], 1413 [@https://svn.boost.org/trac/boost/ticket/3822 #3822]). 1414* Fixed a problem with the lifetime of handler memory, where Windows needs the 1415 `OVERLAPPED` structure to be valid until both the initiating function call 1416 has returned and the completion packet has been delivered. 1417* Don't block signals while performing system calls, but instead restart the 1418 calls if they are interrupted. 1419* Documented the guarantee made by strand objects with respect to order of 1420 handler invocation. 1421* Changed strands to use a pool of implementations, to make copying of strands 1422 cheaper. 1423* Ensured that kqueue support is enabled for BSD platforms 1424 ([@https://svn.boost.org/trac/boost/ticket/3626 #3626]). 1425* Added a `boost_` prefix to the `extern "C"` thread entry point function 1426 ([@https://svn.boost.org/trac/boost/ticket/3809 #3809]). 1427* In `getaddrinfo` emulation, only check the socket type (`SOCK_STREAM` or 1428 `SOCK_DGRAM`) if a service name has been specified. This should allow the 1429 emulation to work with raw sockets. 1430* Added a workaround for some broken Windows firewalls that make a socket 1431 appear bound to 0.0.0.0 when it is in fact bound to 127.0.0.1. 1432* Applied a fix for reported excessive CPU usage under Solaris 1433 ([@https://svn.boost.org/trac/boost/ticket/3670 #3670]). 1434* Added some support for platforms that use older compilers such as g++ 2.95 1435 ([@https://svn.boost.org/trac/boost/ticket/3743 #3743]). 1436 1437[heading Asio 1.4.3 / Boost 1.40] 1438 1439* Added a new ping example to illustrate the use of ICMP sockets. 1440* Changed the `buffered*_stream<>` templates to treat 0-byte reads and writes as 1441 no-ops, to comply with the documented type requirements for `SyncReadStream`, 1442 `AsyncReadStream`, `SyncWriteStream` and `AsyncWriteStream`. 1443* Changed some instances of the `throw` keyword to `boost::throw_exception()` to 1444 allow Asio to be used when exception support is disabled. Note that the SSL 1445 wrappers still require exception support 1446 ([@https://svn.boost.org/trac/boost/ticket/2754 #2754]). 1447* Made Asio compatible with the OpenSSL 1.0 beta 1448 ([@https://svn.boost.org/trac/boost/ticket/3256 #3256]). 1449* Eliminated a redundant system call in the Solaris [^/dev/poll] backend. 1450* Fixed a bug in resizing of the bucket array in the internal hash maps 1451 ([@https://svn.boost.org/trac/boost/ticket/3095 #3095]). 1452* Ensured correct propagation of the error code when a synchronous accept fails 1453 ([@https://svn.boost.org/trac/boost/ticket/3216 #3216]). 1454* Ensured correct propagation of the error code when a synchronous read or 1455 write on a Windows HANDLE fails. 1456* Fixed failures reported when `_GLIBCXX_DEBUG` is defined 1457 ([@https://svn.boost.org/trac/boost/ticket/3098 #3098]). 1458* Fixed custom memory allocation support for timers 1459 ([@https://svn.boost.org/trac/boost/ticket/3107 #3107]). 1460* Tidied up various warnings reported by g++ 1461 ([@https://svn.boost.org/trac/boost/ticket/1341 #1341], 1462 [@https://svn.boost.org/trac/boost/ticket/2618 #2618]). 1463* Various documentation improvements, including more obvious hyperlinks to 1464 function overloads, header file information, examples for the handler type 1465 requirements, and adding enum values to the index 1466 ([@https://svn.boost.org/trac/boost/ticket/3157 #3157], 1467 [@https://svn.boost.org/trac/boost/ticket/2620 #2620]). 1468 1469[heading Asio 1.4.2 / Boost 1.39] 1470 1471* Implement automatic resizing of the bucket array in the internal hash maps. 1472 This is to improve performance for very large numbers of asynchronous 1473 operations and also to reduce memory usage for very small numbers. A new 1474 macro `BOOST_ASIO_HASH_MAP_BUCKETS` may be used to tweak the sizes used for 1475 the bucket arrays. (N.B. this feature introduced a bug which was fixed in 1476 Asio 1.4.3 / Boost 1.40.) 1477* Add performance optimisation for the Windows IOCP backend for when no timers 1478 are used. 1479* Prevent locale settings from affecting formatting of TCP and UDP endpoints 1480 ([@https://svn.boost.org/trac/boost/ticket/2682 #2682]). 1481* Fix a memory leak that occurred when an asynchronous SSL operation's 1482 completion handler threw an exception 1483 ([@https://svn.boost.org/trac/boost/ticket/2910 #2910]). 1484* Fix the implementation of `io_control()` so that it adheres to the 1485 documented type requirements for IoControlCommand 1486 ([@https://svn.boost.org/trac/boost/ticket/2820 #2820]). 1487* Fix incompatibility between Asio and ncurses.h 1488 ([@https://svn.boost.org/trac/boost/ticket/2156 #2156]). 1489* On Windows, specifically handle the case when an overlapped `ReadFile` call 1490 fails with `ERROR_MORE_DATA`. This enables a hack where a 1491 `windows::stream_handle` can be used with a message-oriented named pipe 1492 ([@https://svn.boost.org/trac/boost/ticket/2936 #2936]). 1493* Fix system call wrappers to always clear the error on success, as POSIX 1494 allows successful system calls to modify errno 1495 ([@https://svn.boost.org/trac/boost/ticket/2953 #2953]). 1496* Don't include termios.h if `BOOST_ASIO_DISABLE_SERIAL_PORT` is defined 1497 ([@https://svn.boost.org/trac/boost/ticket/2917 #2917]). 1498* Cleaned up some more MSVC level 4 warnings 1499 ([@https://svn.boost.org/trac/boost/ticket/2828 #2828]). 1500* Various documentation fixes 1501 ([@https://svn.boost.org/trac/boost/ticket/2871 #2871]). 1502 1503[heading Asio 1.4.1 / Boost 1.38] 1504 1505* Improved compatibility with some Windows firewall software. 1506* Ensured arguments to `windows::overlapped_ptr::complete()` are correctly 1507 passed to the completion handler 1508 ([@https://svn.boost.org/trac/boost/ticket/2614 #2614]). 1509* Fixed a link problem and multicast failure on QNX 1510 ([@https://svn.boost.org/trac/boost/ticket/2504 #2504], 1511 [@https://svn.boost.org/trac/boost/ticket/2530 #2530]). 1512* Fixed a compile error in SSL support on MinGW / g++ 3.4.5. 1513* Drop back to using a pipe for notification if eventfd is not available at 1514 runtime on Linux ([@https://svn.boost.org/trac/boost/ticket/2683 #2683]). 1515* Various minor bug and documentation fixes 1516 ([@https://svn.boost.org/trac/boost/ticket/2534 #2534], 1517 [@https://svn.boost.org/trac/boost/ticket/2541 #2541], 1518 [@https://svn.boost.org/trac/boost/ticket/2607 #2607], 1519 [@https://svn.boost.org/trac/boost/ticket/2617 #2617], 1520 [@https://svn.boost.org/trac/boost/ticket/2619 #2619]). 1521 1522[heading Asio 1.4.0 / Boost 1.37] 1523 1524* Enhanced CompletionCondition concept with the signature 1525 `size_t CompletionCondition(error_code ec, size_t total)`, where the return 1526 value indicates the maximum number of bytes to be transferred on the next 1527 read or write operation. (The old CompletionCondition signature is still 1528 supported for backwards compatibility). 1529* New windows::overlapped_ptr class to allow arbitrary overlapped I/O 1530 functions (such as TransmitFile) to be used with Asio. 1531* On recent versions of Linux, an eventfd descriptor is now used (rather than 1532 a pipe) to interrupt a blocked select/epoll reactor. 1533* Added const overloads of lowest_layer(). 1534* Synchronous read, write, accept and connect operations are now thread safe 1535 (meaning that it is now permitted to perform concurrent synchronous 1536 operations on an individual socket, if supported by the OS). 1537* Reactor-based io_service implementations now use lazy initialisation to 1538 reduce the memory usage of an io_service object used only as a message 1539 queue. 1540 1541[heading Asio 1.2.0 / Boost 1.36] 1542 1543* Added support for serial ports. 1544* Added support for UNIX domain sockets. 1545* Added support for raw sockets and ICMP. 1546* Added wrappers for POSIX stream-oriented file descriptors (excluding regular 1547 files). 1548* Added wrappers for Windows stream-oriented `HANDLE`s such as named pipes 1549 (requires `HANDLE`s that work with I/O completion ports). 1550* Added wrappers for Windows random-access `HANDLE`s such as files (requires 1551 `HANDLE`s that work with I/O completion ports). 1552* Added support for reactor-style operations (i.e. they report readiness but 1553 perform no I/O) using a new `null_buffers` type. 1554* Added an iterator type for bytewise traversal of buffer sequences. 1555* Added new `read_until()` and `async_read_until()` overloads that take a 1556 user-defined function object for locating message boundaries. 1557* Added an experimental two-lock queue (enabled by defining 1558 `BOOST_ASIO_ENABLE_TWO_LOCK_QUEUE`) that may provide better `io_service` 1559 scalability across many processors. 1560* Various fixes, performance improvements, and more complete coverage of the 1561 custom memory allocation support. 1562 1563[heading Asio 1.0.0 / Boost 1.35] 1564 1565First release of Asio as part of Boost. 1566 1567[endsect] 1568
