asio/src/doc/history.qbk

[/
 / Copyright (c) 2003-2011 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.5.3]

* 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`.

* Added new `asio::buffer()` overloads for `std::array`, when available. The
  support is automatically enabled when compiling in [^-std=c++0x] mode on g++
  4.3 or higher, or when using MSVC 10. The support may be explicitly enabled
  by defining `(BOOST_)ASIO_HAS_STD_ARRAY`, or disabled by defining
  `(BOOST_)ASIO_DISABLE_STD_ARRAY`.

* Changed to use the C++0x standard library templates `array`, `shared_ptr`,
  `weak_ptr` and `atomic` when they are available, rather than the Boost
  equivalents.

* Support for `std::error_code` and `std::system_error` is no longer enabled by
  default for g++ 4.5, as that compiler's standard library does not implement
  `std::system_error::what()` correctly.

[heading Asio 1.5.2]

* Added support for C++0x move construction and assignment to sockets, serial
  ports, POSIX descriptors and Windows handles.

* 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.

* 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.

* The kqueue flag `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.

* Changed exception reporting to include the function name in exception `what()`
  messages.

* Fixed an insufficient initialisers warning with MinGW.

* Changed the `shutdown_service()` member functions to be private.

* Added archetypes for testing socket option functions.

* Added a missing lock in `signal_set_service::cancel()`.

* Fixed a copy/paste error in `SignalHandler` example.

* Added the inclusion of the signal header to `signal_set_service.hpp` so that
  constants like `NSIG` may be used.

* Changed the `signal_set_service` implementation so that it doesn't assume
  that `SIGRTMAX` is a compile-time constant.

* 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.

[heading Asio 1.5.1]

* Added support for signal handling, using a new class called `signal_set`.
  Programs may add one or more signals to the set, and then perform an
  `async_wait()` operation. The specified handler will be called when one of
  the signals occurs. The same signal number may registered with multiple
  `signal_set` objects, however the signal number must be used only with Asio.

* Added handler tracking, a new debugging aid. When enabled by defining
  `(BOOST_)ASIO_ENABLE_HANDLER_TRACKING`, Asio writes debugging output to the
  standard error stream. The output records asynchronous operations and the
  relationships between their handlers. It may be post-processed using the
  included [^handlerviz.pl] tool to create a visual representation of the
  handlers (requires GraphViz).

* Fixed a bug in `asio::streambuf` where the `consume()` function did not
  always update the internal buffer pointers correctly. The problem may occur
  when the `asio::streambuf` is filled with data using the standard C++ member
  functions such as `sputn()`. (Note: the problem does not manifest when the
  streambuf is populated by the Asio free functions `read()`,
  `async_read()`, `read_until()` or `async_read_until()`.)

* Fixed a bug on kqueue-based platforms, where reactor read operations that
  return false from their `perform()` function are not correctly re-registered
  with kqueue.

* Support for `std::error_code` and `std::system_error` is no longer enabled by
  default for MSVC10, as that compiler's standard library does not implement
  `std::system_error::what()` correctly.

* Modified the `buffers_iterator<>` and `ip::basic_resolver_iterator` classes
  so that the value_type typedefs are non-const byte types. 

[heading Asio 1.5.0]

* Added support for timeouts on socket iostreams, such as `ip::tcp::iostream`.
  A timeout is set by calling `expires_at()` or `expires_from_now()` to
  establish a deadline. Any socket operations which occur past the deadline
  will put the iostream into a bad state.

* Added a new `error()` member function to socket iostreams, for retrieving the
  error code from the most recent system call.

* Added a new `basic_deadline_timer::cancel_one()` function. This function lets
  you cancel a single waiting handler on a timer. Handlers are cancelled in
  FIFO order.

* Added a new `transfer_exactly()` completion condition. This can be used to
  send or receive a specified number of bytes even if the total size of the
  buffer (or buffer sequence) is larger.

* Added new free functions `connect()` and `async_connect()`. These operations
  try each endpoint in a list until the socket is successfully connected.

* Extended the `buffer_size()` function so that it works for buffer sequences
  in addition to individual buffers.

* Added a new `buffer_copy()` function that can be used to copy the raw bytes
  between individual buffers and buffer sequences.

* Added new non-throwing overloads of `read()`, `read_at()`, `write()` and
  `write_at()` that do not require a completion condition.

* Added friendlier compiler errors for when a completion handler does not meet
  the necessary type requirements. When C++0x is available (currently supported
  for g++ 4.5 or later, and MSVC 10), `static_assert` is also used to generate
  an informative error message. This checking may be disabled by defining
  `(BOOST_)ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS`.

* Added support for using `std::error_code` and `std::system_error`, when
  available. The support is automatically enabled when compiling in
  [^-std=c++0x] mode on g++ 4.5 or higher, or when using MSVC 10. The support
  may be explicitly enabled by defining `ASIO_HAS_STD_SYSTEM_ERROR`, or
  disabled by defining `ASIO_DISABLE_STD_SYSTEM_ERROR`. (Available in non-Boost
  version of Asio only.)

* Made the `is_loopback()`, `is_unspecified()` and `is_multicast()` functions
  consistently available across the `ip::address`, `ip::address_v4` and
  `ip::address_v6` classes.

* 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.

* For consistency with the C++0x standard library, deprecated the `native_type`
  typedefs in favour of `native_handle_type`, and the `native()` member
  functions in favour of `native_handle()`.

* Added a `release()` member function to posix descriptors. This function
  releases ownership of the underlying native descriptor to the caller.

* Added support for sequenced packet sockets (`SOCK_SEQPACKET`).

* Added a new `io_service::stopped()` function that can be used to determine
  whether the `io_service` has stopped (i.e. a `reset()` call is needed prior
  to any further calls to `run()`, `run_one()`, `poll()` or `poll_one()`).

* Reduced the copying of handler function objects.

* Added support for C++0x move construction to further reduce copying of
  handler objects. Move support is enabled when compiling in [^-std=c++0x] mode
  on g++ 4.5 or higher, or when using MSVC10.

* Removed the dependency on OS-provided macros for the well-known IPv4 and IPv6
  addresses. This should eliminate the annoying "missing braces around
  initializer" warnings.

* 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.

* Changed the SSL error category to return error strings from the OpenSSL
  library.

* Changed the separate compilation support such that, to use Asio's SSL
  capabilities, you should also include 'asio/ssl/impl/src.hpp` in one source
  file in your program.

* Removed the deprecated member functions named `io_service()`. The
  `get_io_service()` member functions should be used instead.

* Removed the deprecated typedefs `resolver_query` and `resolver_iterator` from
  the `ip::tcp`, `ip::udp` and `ip::icmp` classes.

* Fixed a compile error on some versions of g++ due to anonymous enums.

* Added an explicit cast to the `FIONBIO` constant to int to suppress a compiler
  warning on some platforms.

* Fixed warnings reported by g++'s [^-Wshadow] compiler option.

[heading Asio 1.4.8]

* 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.

[heading Asio 1.4.7]

* Fixed a problem on kqueue-based platforms where a `deadline_timer` may
  never fire if the `io_service` is running in a background thread.

* Fixed a const-correctness issue that prevented valid uses of
  `has_service<>` from compiling.

* Fixed MinGW cross-compilation.

* Removed dependency on deprecated Boost.System functions (Boost.Asio only).

* Ensured `close()`/`closesocket()` failures are correctly propagated.

* Added a check for errors returned by `InitializeCriticalSectionAndSpinCount`.

* Added support for hardware flow control on QNX.

* Always use `pselect()` on HP-UX, if it is available.

* Ensured handler arguments are passed as lvalues.

* Fixed Windows build when thread support is disabled.

* Fixed a Windows-specific problem where `deadline_timer` objects with expiry
  times set more than 5 minutes in the future may never expire.

* Fixed the resolver backend on BSD platforms so that an empty service name
  resolves to port number `0`, as per the documentation.

* Fixed read operations so that they do not accept buffer sequences of type
  `const_buffers_1`.

* Redefined `Protocol` and `id` to avoid clashing with Objective-C++ keywords.

* Fixed a `vector` reallocation performance issue that can occur when there are
  many active `deadline_timer` objects.

* Fixed the kqueue backend so that it compiles on NetBSD.

* Fixed the socket `io_control()` implementation on 64-bit Mac OS X and BSD
  platforms.

* Fixed a Windows-specific problem where failures from `accept()` are
  incorrectly treated as successes.

* Deprecated the separate compilation header `asio/impl/src.cpp` in
  favour of `asio/impl/src.hpp`.

[heading Asio 1.4.6]

* 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, include
  `asio/impl/src.cpp` in 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`.

* Ensured unsigned char is used with `isdigit` in `getaddrinfo` emulation.

* Fixed handling of very small but non-zero timeouts.

* 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`.
  
* Implemented cancellation of `null_buffers` operations on Windows.

[heading Asio 1.4.5]

* 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.

* 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.

* Fixed a bug where 0-byte asynchronous reads were incorrectly passing
  an `error::eof` result to the completion handler.

* Changed the `io_control()` member functions to always call `ioctl` on
  the underlying descriptor when modifying blocking mode.

* Changed the resolver implementation so that it no longer requires 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]

* 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.

* Restricted MSVC buffer debugging workaround to 2008, as it causes a
  crash with 2010 beta 2.

* 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.

* Added a `boost_` prefix to the `extern "C"` thread entry point
  function.

* 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.

* Added some support for platforms that use older compilers such as g++
  2.95.

[heading Asio 1.4.3]

* 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.

* Made Asio compatible with the OpenSSL 1.0 beta.

* 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.

* Ensured correct propagation of the error code when a synchronous
  accept fails.

* 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.

* Fixed custom memory allocation support for timers.

* Tidied up various warnings reported by g++.

* 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.

[heading Asio 1.4.2]

* 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.

* Fix a memory leak that occurred when an asynchronous SSL operation's
  completion handler threw an exception.

* Fix the implementation of `io_control()` so that it adheres to the
  documented type requirements for IoControlCommand.

* Fix incompatibility between Asio and ncurses.h.

* 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.

* Fix system call wrappers to always clear the error on success, as
  POSIX allows successful system calls to modify errno.

* Don't include termios.h if `(BOOST_)ASIO_DISABLE_SERIAL_PORT` is
  defined.

* Cleaned up some more MSVC level 4 warnings.

* Various documentation fixes.

[heading Asio 1.4.1]

* Improved compatibility with some Windows firewall software.

* Ensured arguments to `windows::overlapped_ptr::complete()` are correctly
  passed to the completion handler.

* Fixed a link problem and multicast failure on QNX.

* 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.

* Various minor bug and documentation fixes.

[heading Asio 1.4.0]

* 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]

* 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]

First stable release of Asio.

[endsect]