|  | Home | Libraries | People | FAQ | More | 
asio::connect() when the connect_condition
          returns an end iterator (#12354).
        getsockname
          reports 0.0.0.0 (#12406).
        SSL_COMP_free_compression_methods
          to fix two memory leaks reported at shutdown, for OpenSSL versions >=
          1.0.2 and < 1.1.0 (#10795).
        use_future compile
          error encountered on some standard library implementations, by changing
          std::allocator<void>
          use to a non-void template parameter.
        getaddrinfo
          by default on Apple OSes, rather than emulation in terms of getipnodebyname.
        OPENSSL_NO_SSL3
          feature test #define
          (#11754).
        SSL_CTX_clear_chain_certs
          function, if available.
        strncat
          in the getaddrinfo emulation
          and in the SSL wrapper's password handling.
        CreateEventW
          rather than CreateEvent
          (#11732).
        ConnectEx
          function are mapped to their portable equivalents (#10744).
        BOOST_ASIO_DISABLE_CONNECTEX
          to allow use of ConnectEx
          to be explicitly disabled.
        windows::object_handle
          when there are pending wait operations on destruction (#10624).
        EINVAL.
        ssl::stream<>
          bug that may result in spurious 'short read' errors.
        ERR_remove_state.
        std::addressof
          with g++ (#10982).
        join_group
          failures as non-fatal.
        std::endl
          to ensure output is flushed.
        yield_context
          object with asynchronous operations.
        yield_context to
          allow reentrant calls to the completion handler from an initiating function.
        kqueue reactor so that it works on FreeBSD
          (#10606).
        kqueue reactor which resulted
          in spinning when using serial ports on Mac OS (#10496).
        kqueue reactor support for read-only file descriptors
          (#10367).
        /dev/poll reactor
          (#10350, #10572).
        WSASocketW,
          as WSASocketA has been
          deprecated (#10534).
        use_future
          and spawn()
          are not made available when including the asio.hpp
          convenience header (#10567).
        asio::strand
          as deprecated. Use asio::io_service::strand
          instead.
        kqueue backend that was introduced
          in Asio 1.10.2.
        gcc
          on AIX.
        gcc problem to do with anonymous enums
          (#10042).
        HANDLE
          backend change to ignore ERROR_MORE_DATA.
          Instead, the error will be propagated as with any other (i.e. in an error_code or thrown as a system_error), and the number of bytes
          transferred will be returned. For code that needs to handle partial messages,
          the error_code overload
          should be used (#10034).
        signal_set
          implementation's signal number check (#9324).
        SO_UPDATE_CONNECT_CONTEXT
          is defined (#10016).
        VerifyVersionInfo rather than GetVersionEx, as GetVersionEx
          has been deprecated.
        asio::spawn()
          to work correctly with new Boost.Coroutine interface (#9442, #9928).
        asio::spawn() coroutines are correctly unwound when
          cleaned up by the io_service
          destructor (#9731).
        io_service::wrap()
          and strand::wrap()
          (#9741).
        ConnectEx,
          if available, for connection-oriented IP sockets.
        io_service
          backend for non-Windows (and non-IOCP Windows) platforms to use a single
          condition variable per io_service
          instance. This addresses a potential race condition when run_one()
          is used from multiple threads.
        boost::chrono and std::chrono
          clocks (#9662, #9778).
        EV_CLEAR
          handling in the kqueue backend, to address other cases where the close()
          system call may hang on Mac OS X.
        resolver_query_base::flags::operator~ (#9548).
        select reactor
          more efficient on Windows for large numbers of sockets (#9528).
        gcc
          (#9550).
        GetQueuedCompletionStatus
          timeout workaround on recent versions of Windows.
        io_service,
                strand, buffers,
                composed operations, timers, etc., should all work as normal.
              cancel()
                function is not supported for sockets. Asynchronous operations may
                only be cancelled by closing the socket.
              null_buffers
                are not supported.
              tcp::no_delay and socket_base::keep_alive
                options are supported.
              async_connect
          were not correctly propagated through to the completion handler (#8795).
        io_service.
          When the bug occurs, the result of an asynchronous operation (error and
          bytes tranferred) is incorrectly discarded and zero values used instead.
          For TCP sockets this results in spurious end-of-file notifications (#8933).
        async_wait
          on a signal that is already raised (#8738).
        async_write_at
          operations (#8669).
        HANDLE
          backend to treat ERROR_MORE_DATA
          as a non-fatal error when returned by GetOverlappedResult
          for a synchronous read (#8722).
        generic
          as a keyword. Added a workaround that renames the namespace to cpp_generic when those language extensions
          are in effect.
        async_result support in Boost 1.54. In
          particular, the buffered stream templates have been updated so that they
          adhere to current handler patterns (#9000, #9001).
        use_future support
          for Microsoft Visual Studio 2012.
        std::min in the Windows IOCP backend to avoid
          a dependency on the <algorithm> header (#8758).
        SSL_CTX_clear_options function (#9273).
        handler_type
          and async_result, that
          allow the customisation of the return type of an initiating function.
        asio::spawn()
          function, a high-level wrapper for running stackful coroutines, based on
          the Boost.Coroutine library. The spawn() function enables programs to implement
          asynchronous logic in a synchronous manner. For example: size_t n
          = my_socket.async_read_some(my_buffer, yield);. For further information, see Stackful
          Coroutines.
        asio::use_future special value, which provides
          first-class support for returning a C++11 std::future
          from an asynchronous operation's initiating function. For example: future<size_t>
          = my_socket.async_read_some(my_buffer, asio::use_future);. For further information, see C++
          2011 Support - Futures.
        asio_handler_is_continuation.
          Asynchronous operations may represent a continuation of the asynchronous
          control flow associated with the current executing handler. The asio_handler_is_continuation hook can
          be customised to return true
          if this is the case, and Asio's implementation can use this knowledge to
          optimise scheduling of the new handler. To cover common cases, Asio customises
          the hook for strands, spawn() and composed asynchronous operations.
        generic::datagram_protocol,
          generic::raw_protocol, generic::seq_packet_protocol
          and generic::stream_protocol, which implement the
          Protocol type requirements,
          but allow the user to specify the address family (e.g. AF_INET)
          and protocol type (e.g. IPPROTO_TCP)
          at runtime. For further information, see Support
          for Other Protocols.
        ip::tcp::socket
          can be converted into a generic::stream_protocol::socket
          via move construction. For further information, see Support
          for Other Protocols.
        basic_socket_acceptor<>'s accept() and async_accept() functions to allow a new connection to
          be accepted directly into a socket of a more generic type. For example,
          an ip::tcp::acceptor can be used to accept into a
          generic::stream_protocol::socket object. For further information,
          see Support
          for Other Protocols.
        ssl::stream<> class's handshake() and async_handshake() functions have been added. These
                accept a ConstBufferSequence
                to be used as initial input to the ssl engine for the handshake procedure.
              ssl::context
                objects.
              set_verify_depth() function to the ssl::context
                and ssl::stream<>
                classes.
              add_certificate_authority(), use_certificate(), use_certificate_chain(), use_private_key(), use_rsa_private_key() and use_tmp_dh(), have been added to the ssl::context class.
              ssl::context to automatically disable
                SSL compression by default. To enable, use the new ssl::context::clear_options()
                function, as in my_context.clear_options(ssl::context::no_compression).
              signal_set
          implementation.
        #warning
          directive #7939.
        epoll
          implementation.
        error_code with an invalid
          (i.e. NULL) error_category #8613.
        basic_waitable_timer's
          underlying implementation so that it can handle any time_point
          value without overflowing the intermediate duration objects.
        run()
          and poll()
          on the same io_service
          object #8354.
        ssl::rfc2818_verification
          class.
        boost/asio/detail/winsock_init.hpp
          for details.
        basic_socket::get_option's
          documentation (#7562).
        long rather
          than int for SSL_CTX options,
          to match OpenSSL (#7209).
        _snwprintf
          to address a compile error due to the changed swprintf
          signature in recent versions of MinGW (#7373).
        io_service threads due
          to running out of work (#7552).
        noexcept qualifier
          for error categories (#7797).
        accept
          as non-fatal (#7488).
        ip::tcp::iostream
          and C++11 (#7162).
        #include <cctype>, needed for some versions of MinGW.
        gcc's atomic builtins on ARM CPUs, when
          available (#7140).
        io_service
          has been destroyed.
        epoll_create1()
          function but always fail with ENOSYS
          (#7012).
        buffered_write_stream
          (#6310).
        epoll_reactor
          backend to do lazy registration for EPOLLOUT
          events.
        epoll_reactor
          handling of out-of-band data, which was broken by an incomplete fix in
          the last release.
        OPENSSL_NO_ENGINE
          feature test #define
          (#6432).
        windows::object_handle so that it works with Windows
          compilers that support C++11 move semantics (such as g++).
        g++ 4.7 when compiling in C++11 mode
          (#6620).
        signal_set
          handlers were not being delivered when the io_service
          was constructed with a concurrency_hint
          of 1 (#6657).
        basic_waitable_timer
          based around the C++11 clock type requirements. It may be used with the
          clocks from the C++11 <chrono>
          library facility or, if those are not available, Boost.Chrono. The typedefs
          high_resolution_timer,
          steady_timer and system_timer may be used to create timer
          objects for the standard clock types.
        windows::object_handle class for performing waits
          on Windows kernel objects. Thanks go to Boris Schaeling for contributing
          substantially to the development of this feature.
        connect()
          can return EAGAIN in certain circumstances. Remapped this to another error
          so that it doesn't look like a non-blocking operation (#6048).
        buffered_write_stream
          (#6310).
        io_service is repeatedly run without
          anything to do (#6321).
        concurrency_hint
                is 1) to eliminate a lock/unlock pair.
              epoll_reactor
                speculative operations to be performed without holding the lock.
              epoll_reactor's
                I/O operation immediately before the corresponding handler is called.
                This also improves scalability across CPUs when multiple threads
                are running the io_service.
              boost::array
                or std::array) of exactly two buffers.
              async_read_until
          (#5688).
        signal()
          function from the global namespace (#5722).
        deadline_timer
          implementation so that it does not read the clock unless the timer heap
          is non-empty.
        null_buffers
          operations so that they obey the user's non-blocking setting (#5756).
        fd_set
          at runtime when using Windows.
        epoll_reactor
          initialisation (#6006).
        BOOST_ASIO_STRAND_IMPLEMENTATIONS to
          the desired number.
        BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION
          flag which switches the allocation of strand implementations to use a round-robin
          approach rather than hashing.
        strand.post()
          is used.
        signal_set. Programs may add one or more
          signals to the set, and then perform an async_wait() operation. The specified handler will
          be called when one of the signals occurs. The same signal number may be
          registered with multiple signal_set
          objects, however the signal number must be used only with Asio. Addresses
          #2879.
        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).
        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.
        error()
          member function to socket iostreams, for retrieving the error code from
          the most recent system call.
        basic_deadline_timer::cancel_one() function. This function lets you cancel
          a single waiting handler on a timer. Handlers are cancelled in FIFO order.
        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.
        connect() and async_connect(). These operations try each endpoint in
          a list until the socket is successfully connected, and are useful for creating
          TCP clients that work with both IPv4 and IPv6.
        buffer_size() function so that it works for buffer
          sequences in addition to individual buffers.
        buffer_copy() function that can be used to copy the
          raw bytes between individual buffers and buffer sequences.
        read(), read_at(), write() and write_at() that do not require a completion condition.
        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.
        BOOST_ASIO_ENABLE_OLD_SSL.
          Addresses #3702,
          #3958.
        boost/asio/ssl/impl/src.hpp
          in one source file in your program.
        is_loopback(),
          is_unspecified()
          and is_multicast()
          functions consistently available across the ip::address,
          ip::address_v4 and ip::address_v6
          classes (#3939).
        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.
        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.
        io_control()
          member function for socket acceptors (#3297).
        release()
          member function to posix descriptors. This function releases ownership
          of the underlying native descriptor to the caller. Addresses #3900.
        SOCK_SEQPACKET).
        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()).
        native_type typedefs in favour of native_handle_type, and the native()
          member functions in favour of native_handle().
        fork() system call. Programs that use fork()
          must call io_service.notify_fork()
          at the appropriate times. Two new examples have been added showing how
          to use this feature. Addresses #3238,
          #4162.
        close() system call. In particular, assume that
          most operating systems won't have close() fail with EWOULDBLOCK,
          but if it does then set the blocking mode and restart the call. If any
          other error occurs, assume the descriptor is closed. Addresses #3307.
        asio::buffer()
          overloads for std::array, when available.
        array, shared_ptr,
          weak_ptr and atomic when they are available, rather
          than the Boost equivalents.
        what()
          messages.
        shutdown_service() member functions to be private.
        ip::basic_endpoint<> objects (such as ip::tcp::endpoint and ip::udp::endpoint).
        assign()
          may have been dup()-ed,
          and so require explicit deregistration from the reactor (#4971).
        io_service(). The get_io_service() member functions should be used instead.
        resolver_query
          and resolver_iterator from
          the ip::tcp, ip::udp
          and ip::icmp classes.
        buffers_iterator<> and ip::basic_resolver_iterator
          classes so that the value_type typedefs are non-const byte types.
        -Wshadow compiler option
          (#3905).
        FIONBIO
          constant to int, to suppress a compiler warning on some platforms (#5128).
        tick_count_timer example by making
          the duration type signed. Previously, a wait on an already-passed deadline
          would not return for a very long time (#5418).
        EV_ONESHOT seems to cause
          problems on some versions of Mac OS X, with the io_service
          destructor getting stuck inside the close() system call. Changed the kqueue backend
          to use EV_CLEAR instead
          (#5021).
        g++ due
          to the use of anonymous enums (#4883).
        EWOULDBLOCK are
          not correctly re-registered with kqueue.
        asio::streambuf to ensure that its internal
          pointers are updated correctly after the data has been modified using
          std::streambuf member functions.
        ip::address_v4::broadcast() is used on 64-bit platforms.
        deadline_timer
          may never fire if the io_service
          is running in a background thread (#4568).
        has_service<>
          from compiling (#4638).
        close()/closesocket()
          failures are correctly propagated (#4573).
        InitializeCriticalSectionAndSpinCount
          (#4574).
        pselect()
          on HP-UX, if it is available (#4578).
        deadline_timer
          objects with expiry times set more than 5 minutes in the future may never
          expire (#4745).
        resolver backend
          on BSD platforms so that an empty service name resolves to port number
          0, as per the documentation
          (#4690).
        const_buffers_1 (#4746).
        Protocol and
          id to avoid clashing with
          Objective-C++ keywords (#4191).
        vector reallocation
          performance issue that can occur when there are many active deadline_timer objects (#4780).
        io_control() implementation on 64-bit Mac OS X and
          BSD platforms (#4782).
        accept() are incorrectly treated as successes
          (#4859).
        <boost/asio/impl/src.cpp>
          in favour of <boost/asio/impl/src.hpp> (#4560).
        #includes, e.g. if the
          program uses boost::array but does not explicitly include
          <boost/array.hpp>.)
        deadline_timer
          implementation to improve performance.
        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.
        #include
          <boost/asio/impl/src.cpp> to one source file in a program, then
          build the program with BOOST_ASIO_SEPARATE_COMPILATION
          defined in the project/compiler settings. Alternatively, BOOST_ASIO_DYN_LINK may be defined to
          build a separately-compiled Asio as part of a shared library.
        BOOST_ASIO_DISABLE_FENCED_BLOCK
          to permit the disabling of memory fences around completion handlers, even
          if thread support is enabled.
        const
          types.
        null_buffers
          variant of async_send_to
          (#4170).
        unsigned char
          is used with isdigit in
          getaddrinfo emulation (#4201).
        operator+
          overload in buffers_iterator
          (#4382).
        null_buffers
          operations on Windows.
        timerfd
          for dispatching timers on Linux, when available.
        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.
        #define NOMINMAX
          for all Windows compilers. Users can define BOOST_ASIO_NO_NOMINMAX
          to suppress this definition (#3901).
        error::eof result to the completion handler
          (#4023).
        io_control() member functions to always call ioctl on the underlying descriptor when
          modifying blocking mode (#3307).
        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.
        select().
        BOOST_ASIO_DISABLE_THREADS
          macro that allows Asio's threading support to be independently disabled.
        boost::addressof
          to get the address of handler objects, rather than applying operator&
          directly (#2977).
        OVERLAPPED structure
          to be valid until both the initiating function call has returned and the
          completion packet has been delivered.
        boost_ prefix to
          the extern "C"
          thread entry point function (#3809).
        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.
        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.
        throw
          keyword to boost::throw_exception()
          to allow Asio to be used when exception support is disabled. Note that
          the SSL wrappers still require exception support (#2754).
        /dev/poll
          backend.
        _GLIBCXX_DEBUG
          is defined (#3098).
        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.)
        io_control() so that it adheres to the documented
          type requirements for IoControlCommand (#2820).
        ReadFile call fails with ERROR_MORE_DATA. This enables a hack
          where a windows::stream_handle can be used with a message-oriented
          named pipe (#2936).
        BOOST_ASIO_DISABLE_SERIAL_PORT
          is defined (#2917).
        windows::overlapped_ptr::complete() are correctly passed to the completion
          handler (#2614).
        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).
        HANDLEs
          such as named pipes (requires HANDLEs
          that work with I/O completion ports).
        HANDLEs
          such as files (requires HANDLEs
          that work with I/O completion ports).
        null_buffers
          type.
        read_until()
          and async_read_until()
          overloads that take a user-defined function object for locating message
          boundaries.
        BOOST_ASIO_ENABLE_TWO_LOCK_QUEUE) that
          may provide better io_service
          scalability across many processors.
        First release of Asio as part of Boost.