Write version-correct async C++ networking code with Boost.Asio

Helps write or review asynchronous C++ networking code with Boost.Asio or standalone Asio - TCP/UDP servers and clients, SSL/TLS streams, timers, resolvers - across Asio's three API eras: classic pre-1.66 io_service, callback-style completion handlers (the portable baseline from Boost 1.74, or stackful asio::spawn plus yield_context from 1.80), and C++20 coroutines (co_await / awaitable<T>) from Boost 1.77 onward. Its method is to identify the toolchain's actual Boost version and C++ standard first - via find_package(Boost), dpkg -l libboost-dev, brew info boost, or CMAKE_CXX_STANDARD - rather than assume the newest, then follow that style's dedicated reference file, because using a feature above its version floor breaks common distro builds: experimental/awaitable_operators.hpp needs Boost 1.77+, the as_tuple completion token needs 1.79+, co_composed needs 1.85+, the 3-argument asio::spawn needs 1.80+, and any_io_executor needs 1.74+ (Debian bookworm ships 1.74, Ubuntu 20.04 ships 1.71, Debian 9 ships 1.62).

It then applies a set of rules for mistakes it flags as genuinely easy to get wrong: a strand serializes handler execution, not whole composed operations, so two concurrent async_writes on the same strand still interleave bytes on the wire - fixed with a per-connection outbound queue plus an in-flight flag; asio::buffer() is only a view, so its backing storage must outlive the async operation (a coroutine local is fine across a co_await in the same frame, but callback style needs a member, not a local); connections must outlive their handlers via enable_shared_from_this, with self captured in every handler and co_spawn; framing must use composed async_read, never the short-returning async_read_some; as_tuple must always be wrapped as as_tuple(use_awaitable), never used bare; async_accept(make_strand(...)) changes the accepted socket's type to basic_stream_socket<tcp, strand<...>>, so it must be taken by value or auto, never bound to tcp::socket&; and a re-armed timer resolves its pending wait with operation_aborted, which in an idle-timeout loop is the signal to keep waiting, not an error. It closes with a pre-done checklist (style and version-floor match, buffer lifetime, one in-flight write per socket, a shared strand with captured self, composed reads, errors not swallowed, operation_aborted distinguished from real errors, reuse_address set, correct CMake flags, and an actual successful compile) and links three CI-verified worked examples of the same full-duplex framed-protocol server, one per style, verified back to Boost 1.62 for the classic style and Boost 1.83-1.90 for coroutines.

The coroutine-style reference also covers the mechanics beyond the core rules above: DNS resolution with tcp::resolver::async_resolve feeding asio::async_connect; a TCP acceptor pattern that sets reuse_address before the accept loop; multi-threaded io_context::run(), where every handler touching shared state must still be strand-protected even though multiple threads are pumping the same io_context; custom composed operations built with co_composed; newline-delimited protocols via async_read_until versus length-prefixed binary framing (two sequential composed async_reads - a fixed-size length header, then the body - with an explicit maximum-size check, e.g. capping a frame at 16 MiB, before allocating the body buffer); and graceful shutdown via asio::signal_set on SIGINT/SIGTERM, closing the acceptor so in-flight sessions drain before io.run() returns, or calling io.stop() for an immediate stop.

Use it when writing or reviewing async C++ networking code with Boost.Asio or standalone Asio - TCP/UDP servers and clients, SSL/TLS streams, timers, resolvers - or when the code involves io_context, io_service, co_spawn, awaitable, async_read, async_write, strand, asio::spawn, yield_context, or completion-handler callbacks; when the target toolchain is old and coroutine examples won't compile; or when async code compiles but misbehaves - interleaved writes, dangling buffers, sockets closing early, operation_aborted treated as an error. Its own limitations say to stop and ask when the Boost version and C++ standard cannot be determined, since the style choice depends on them; that it does not cover Boost.Beast (HTTP/WebSocket), io_uring backends, or UDP multicast specifics; and that it never replaces actually compiling and testing against the target toolchain. For general modern C++ idioms it assumes and builds on, it points to a separate @cpp-pro skill instead.

Input is the networking task or existing code to review, plus the target Boost/Asio version and C++ standard determined from the build system or package manager if not already known. Output is C++ source in the style matched to that toolchain, following the relevant reference file (coroutines, pre-C++20 callbacks/stackful spawn, classic Boost, SSL/TLS, or CMake build setup), checked against the pre-done list before being considered finished. It also flags a security concern in the code it produces: networking code accepts untrusted input, so a length prefix must be validated before allocating (an attacker-controlled size passed straight into a buffer allocation is a memory-exhaustion vector - cap it), and TLS peer certificates must be verified rather than disabling verification to make a handshake pass.

Wraps Boost.Asio (boost::asio, <boost/asio.hpp>, installed via a system package or brew install boost) and standalone Asio (asio, <asio.hpp>, brew install asio), which share the same API under different namespaces, error-code types (boost::system::error_code versus asio::error_code), and macro prefixes (BOOST_ASIO_ versus ASIO_) - it shows a net:: namespace shim to support both from one codebase. Names GCC's -fcoroutines flag and the BOOST_ERROR_CODE_HEADER_ONLY macro as required CMake configuration for the C++20 style, and Boost::coroutine for stackful asio::spawn.

C++ developers and coding agents writing or debugging asynchronous networking code against Boost.Asio or standalone Asio on a toolchain whose exact version and C++ standard matter - especially anyone hitting version-floor build failures, strand/write-interleaving bugs, or buffer-lifetime crashes. Community-sourced from alexprivalov/boost-asio-skill under the MIT license, added 2026-08-18.