# Bygg en chattserver med Boost.Asio, del 3 - Asynkront med coroutines

18 november 2026 | https://www.ribomation.se/blog/2026/chattserver-boost-asio-del-3/

Tre steg blev tre nivåer. Så slutade förra delen: daytime-klienten, som synkront var tre rader, blev asynkront fyrtio rader nästlade lambdas med varsin felkontroll och en felkod som fick smugglas ut via en variabel. Jag lovade att den skulle bli tre rader igen, fast fortfarande asynkron, och att det skulle ske utan att byta API. Det är den här delen. Vi skriver om echo-servern, daytime-klienten och chattservern med C++20-coroutines, och varje `async_*`\-anrop är detsamma som i förra delen. Det enda som ändras är sista argumentet.

Jag förutsätter att du känner till C++20-coroutines i allmänhet: `co_await`, `co_return`, och att en coroutine är en funktion som kan pausa och återupptas. Jag har skrivit fyra artiklar om det, se länkarna sist, och jag upprepar ingen teori om `promise_type` eller awaiters här. Du behöver inte ha läst dem alla, men den sista, _Asynkrona operationer med coroutines_, är en bra brygga, för där byggde vi för hand precis det Asio ger oss färdigt. Jag förutsätter också förra delen: den asynkrona modellen, `io_context::run()`, completion tokens och `shared_from_this()`.

Artikeln är den tredje av fem, och den är seriens tyngdpunkt. Allt som kommer sedan, TLS, graceful shutdown och WebSocket, skrivs med coroutines. Alla program finns i ett eget GitHub-repo, se länkarna sist. Artikeln visar de rader som bär berättelsen, och i repot finns all kod, plus bygg- och körinstruktioner.

Del

Innehåll

Chattservern

1

Grunderna och synkron I/O

En klient i taget, sedan en tråd per klient

2

Asynkront med callbacks

En tråd utan lås, sedan N trådar med strand:ar

3

Asynkront med coroutines _(denna artikel)_

Samma server med `co_await`, plus en egen C++-klient

4

TLS, UDP och graceful shutdown

Krypterad trafik, servern hittas utan adress, snygg nedstängning

5

Admin-UI med Boost.Beast och WebSocket

HTTPS och WSS, klientlista och statistik live i webbläsaren

* * *

Samma funktion, fyra tokens
---------------------------

I förra delen var sista argumentet till varje `async_*`\-funktion alltid en lambda, och jag nämnde att det argumentet heter _completion token_ och att det finns andra sorter. Nu är det dags att se dem. Här är timern från förra delen, men med samma `async_wait()` anropat med fyra olika tokens:

```cpp
auto wait_twice(asio::io_context& ioc, clk::time_point start) -> asio::awaitable<void> {
    auto timer = asio::steady_timer{ioc, 800ms};
    co_await timer.async_wait(asio::use_awaitable);
    std::println("[{:5} ms] 4. use_awaitable: coroutinen fortsätter efter co_await", ms_since(start));

    timer.expires_after(200ms);
    co_await timer.async_wait();  // ingen token: deferred är default, och den går att co_await:a
    std::println("[{:5} ms] 4. (utan token): samma sak, det är så resten av repot ser ut", ms_since(start));
}

int main() {
    auto start = clk::now();
    auto ioc = asio::io_context{};

    // 1. callback: som i del 2.
    auto t1 = asio::steady_timer{ioc, 200ms};
    t1.async_wait([start](boost::system::error_code) {
        std::println("[{:5} ms] 1. callback: handlern körs inne i run()", ms_since(start));
    });

    // 2. use_future: inget händer i run(), resultatet hämtas med get() nedan.
    auto t2 = asio::steady_timer{ioc, 400ms};
    auto fut = t2.async_wait(asio::use_future);

    // 3. deferred: operationen beskrivs men startar inte förrän den får en token.
    auto t3 = asio::steady_timer{ioc, 600ms};
    auto op = t3.async_wait(asio::deferred);  // samma som t3.async_wait()
    std::println("[{:5} ms] 3. deferred: operationen är skapad men inte startad", ms_since(start));
    std::move(op)([start](boost::system::error_code) {
        std::println("[{:5} ms] 3. deferred: startad med en callback, handlern körs", ms_since(start));
    });

    // 4. use_awaitable: coroutinen startas med co_spawn och körs i run().
    asio::co_spawn(ioc, wait_twice(ioc, start), asio::detached);

    // run() i en egen tråd, så att huvudtråden kan blockera i fut.get().
    auto runner = std::jthread{[&ioc, start] {
        ioc.run();
        std::println("[{:5} ms] run() returnerade: inget mer arbete", ms_since(start));
    }};

    fut.get();
    std::println("[{:5} ms] 2. use_future: get() returnerade i huvudtråden", ms_since(start));
}
```

```text
$ ./build/release/timer/timer
[    0 ms] 3. deferred: operationen är skapad men inte startad
[  200 ms] 1. callback: handlern körs inne i run()
[  400 ms] 2. use_future: get() returnerade i huvudtråden
[  600 ms] 3. deferred: startad med en callback, handlern körs
[  800 ms] 4. use_awaitable: coroutinen fortsätter efter co_await
[ 1000 ms] 4. (utan token): samma sak, det är så resten av repot ser ut
[ 1000 ms] run() returnerade: inget mer arbete
```

Fyra timers, fyra tokens, en och samma funktion. Det är kärnbudskapet i hela serien: callback och coroutine är inte två API:er, utan samma API med olika completion token. Token avgör _hur resultatet levereras_, inte vad som görs. Så här levererar de:

1.  **Callback.** Som i förra delen: handlern körs inne i `run()`, när timern gått av.
2.  **`use_future`.** Anropet returnerar en `std::future<void>`, och resultatet hämtas med `get()`. Det blockerar den anropande tråden, så det är för när en _annan_ tråd än den som kör `run()` vill vänta. Därför kör programmet `run()` i en `jthread`, och huvudtråden väntar i `get()`. Lägg märke till att inget skrivs ut inne i `run()` för token 2. Resultatet går till den som håller futuren.
3.  **`deferred`.** Anropet returnerar ett _operationsobjekt_, som beskriver vad som ska göras utan att göra det. Operationen startar först när objektet anropas med en token, här en callback. Det är en byggsten för att sätta ihop operationer, men dess viktigaste egenskap kommer strax.
4.  **`use_awaitable`.** Anropet returnerar något som går att `co_await`:a inne i en coroutine. Coroutinen pausar, `run()` får tillbaka tråden och kör annat, och när timern gått av återupptas coroutinen på raden efter `co_await`. Det är det den här artikeln handlar om.

Tre nya namn dök upp i token 4. `awaitable<T>` är returtypen för en coroutine som Asio kan köra, där `T` är det den `co_return`:ar. `co_spawn(ex, f(), token)` startar en sådan coroutine på en executor, här `ioc`, och tar själv en completion token som säger vad som ska hända när coroutinen är klar. `detached` är den enklaste: "jag vill inte veta". Vi återkommer till det, för det har en baksida.

Och så den sista raden i `wait_twice()`, där `async_wait()` anropas helt utan token. Sedan Boost 1.86 är `deferred` default-token, så `timer.async_wait()` är samma sak som `timer.async_wait(asio::deferred)`. Och ett deferred-objekt går att `co_await`:a direkt, för en `awaitable` vet hur man startar det med rätt token. Resultatet är att det nästan aldrig behövs någon token alls i coroutine-kod. Resten av artikeln skriver `co_await sock.async_read_some(buf)`, punkt, och `use_awaitable` syns bara i det här exemplet.

> **För dig som kan Node.js.** Node gjorde samma resa som Asio, fast några år tidigare. Callbacks blev Promises, som blev `async`/`await`, och i alla tre fallen var det samma underliggande I/O. Handler, `use_future` och `co_await` är samma trappa. Två skillnader är värda att ha i huvudet. En Promise är _eager_: den börjar köra när den skapas. Ett deferred-objekt och en `awaitable` är _lazy_: inget händer förrän någon `co_await`:ar. Och i Node är det _funktionen_ som bestämmer leveransformen, `fs.readFile` tar en callback och `fs.promises.readFile` returnerar en Promise. I Asio är det _anroparen_ som bestämmer, vid varje anrop, och det är hela poängen med completion tokens.

* * *

Det här byggde vi själva
------------------------

I _Asynkrona operationer med coroutines_ byggde vi en egen liten runtime: en scheduler med en ready-kö, en trådpool för blockerande I/O, `spawn()` och `run()`, och egna awaitables som pausade coroutinen tills datan fanns. Det var en bra övning, för nu kan du läsa Asios coroutine-stöd som en produktionsklar version av samma sak:

Egen runtime

Boost.Asio

`TaskCoroutine<void>`

`awaitable<T>`

`CoroRuntime::spawn()`

`co_spawn(ex, f(), detached)`

`CoroRuntime::run()`

`io_context::run()`

`CoroScheduler`, ready-kön som återupptar coroutines på huvudtråden

executorn, och strand:ar om `run()` körs i flera trådar

`TaskPool`, trådar som utför blockerande I/O

ingen: epoll och io\_uring gör I/O:n asynkron utan extra trådar

`NextLineAwaitable`

det `co_await sock.async_read_until(...)` ger

`LivenessToken`, räknaren som säger om det finns pågående arbete

`io_context`:s räkning av utestående operationer, som avgör när `run()` returnerar

Den rad som skiljer mest är trådpoolen. I vår runtime läste en worker-tråd filen med ett blockerande anrop och postade sedan tillbaka coroutinen till schedulern. Asio behöver ingen sådan tråd, för socketen är asynkron på riktigt: kärnan säger till när det finns data, och `run()` återupptar coroutinen. Allt annat finns kvar, och har samma roll.

* * *

Echo-server med coroutines
--------------------------

Nu till det som del 2 lovade. Här är echo-servern igen, och den här gången finns det ingen `Session`\-klass:

```cpp
auto echo(tcp::socket socket) -> awaitable<void> {
    auto peer = to_string(socket.remote_endpoint());
    std::println("ansluten: {}", peer);

    auto buf = std::array<char, 1024>{};  // lokal igen: lever i coroutinens frame
    try {
        for (;;) {
            auto n = co_await socket.async_read_some(asio::buffer(buf));
            co_await asio::async_write(socket, asio::buffer(buf, n));
        }
    } catch (boost::system::system_error const& e) {
        if (e.code() != asio::error::eof) std::println("fel mot {}: {}", peer, e.what());
    }
    std::println("nedkopplad: {}", peer);
}

auto listener(tcp::acceptor acceptor) -> awaitable<void> {
    for (;;) {
        auto socket = co_await acceptor.async_accept();
        co_spawn(acceptor.get_executor(), echo(std::move(socket)), detached);
    }
}

int main(int argc, char** argv) try {
    auto port = static_cast<unsigned short>(argc > 1 ? std::stoi(argv[1]) : 7000);

    auto ioc = asio::io_context{};
    auto acceptor = tcp::acceptor{ioc, tcp::endpoint{tcp::v4(), port}};
    std::println("echo-server (coroutines) lyssnar på port {}", port);

    co_spawn(ioc, listener(std::move(acceptor)), detached);
    ioc.run();  // alla coroutines körs här, i den här tråden
} catch (std::exception const& e) {
    std::println(stderr, "fel: {}", e.what());
    return 1;
}
```

Jämför med förra delen. Kedjan `do_read → do_write → do_read`, utspridd över två funktioner och två lambdas, är en `for`\-loop igen: läs, skriv, läs, skriv. Det är den synkrona echo-servern från del 1, med `co_await` framför varje anrop. Men den är inte synkron. Varje `co_await` pausar coroutinen, lämnar tillbaka tråden till `run()`, och `run()` kör någon annan klients coroutine under tiden. Två `nc` samtidigt fungerar precis som i förra delen, i en tråd, med samma serverlogg.

Och nu det viktiga: titta på `buf`. Den är en lokal variabel igen. I förra delen var hela avsnittet om livslängd en konsekvens av att `do_read()` returnerade direkt, så att en lokal buffert hade dött innan handlern kördes. Därför blev bufferten en medlem, och därför behövde `Session` äga sig själv via `enable_shared_from_this`. Nu returnerar `echo()` inte förrän klienten kopplat ned. Coroutinen _pausar_ vid `co_await`, och dess lokala variabler ligger i coroutinens frame, som lever tills coroutinen är klar. Bufferten, socketen och `peer` lever alltså exakt så länge som de behövs, utan en klass och utan en `shared_ptr`. Språket löser det som förra delen löste med ett mönster.

Vem äger då coroutinen? `co_spawn` gör det. Den tar `echo(std::move(socket))`, som är ett `awaitable<void>`, och håller det vid liv tills coroutinen kört klart. Det är samma princip som i förra delen, den utestående operationen äger sessionen, men nu är "sessionen" en coroutine-frame och ägandet sköts av `co_spawn`. Accept-loopen är likadan: en `for`\-loop som väntar på nästa klient och startar en coroutine för den.

### Samma server i Node.js

Nu när echo-servern är femton rader är den värd att sätta bredvid sin Node-motsvarighet:

```js
import net from 'node:net';

async function echo(socket) {
    const peer = `${socket.remoteAddress}:${socket.remotePort}`;
    console.log('ansluten:', peer);
    try {
        for await (const chunk of socket) {
            socket.write(chunk);
        }
    } catch (err) {
        console.log(`fel mot ${peer}: ${err.message}`);
    }
    console.log('nedkopplad:', peer);
}

const port = Number(process.argv[2] ?? 7000);
net.createServer(echo).listen(port, () => console.log(`echo-server (Node) lyssnar på port ${port}`));
```

Samma struktur, rad för rad. `async function` motsvarar `awaitable<void>`, `for await` över socketen motsvarar loopen med `co_await async_read_some`, och try/catch runt loopen finns på båda sidor. Det som skiljer är att Node buffrar åt dig: `for await` lämnar ut varje chunk som redan anlänt, medan Asio inte läser något förrän du ber om det. Och `net.createServer(echo)` är `listener()` plus `co_spawn`, inbakat i biblioteket. I förra delen var Node-rutan tvungen att förklara skillnaden mellan error-first callbacks och `error_code`. Nu är de två programmen så lika att det knappt finns något att förklara. Det är det coroutines gör.

* * *

Felhantering i coroutines
-------------------------

I förra delen bytte vi till `error_code` överallt, eftersom det inte fanns någon att kasta ett exception till. Nu finns det någon. När en operation som `co_await`:as misslyckas kastar `co_await` ett `boost::system::system_error`, i coroutinen, på raden där anropet står. Så tumregeln från del 1 gäller igen: exceptions som default, och `error_code` där fel är normalt flöde.

Det är därför `echo()` har try/catch runt sin loop. När klienten kopplar ned ger `async_read_some` eof, som är ett `system_error` med koden `asio::error::eof`, och loopen bryts. Det är lite snålt att använda ett exception för ett förväntat slut, men i en loop som ska avslutas ändå är det den kortaste koden. När eof inte ska avsluta något, som i daytime-klienten strax, finns `as_tuple`:

```cpp
auto [ec, n] = co_await asio::async_read(socket, asio::dynamic_buffer(reply), asio::as_tuple);
if (ec && ec != asio::error::eof) throw boost::system::system_error{ec, "read"};
```

`as_tuple` är en token-adapter: den gör att `co_await` returnerar en tuple med `error_code` och antalet byte, i stället för att kasta. Det finns också `redirect_error(ec)`, som fyller i en `error_code`\-variabel, men `as_tuple` med structured bindings är den form jag tycker läses bäst.

Och så baksidan med `detached`, som jag lovade. Vad händer om ett exception lämnar en coroutine som startats med `co_spawn(ex, f(), detached)`? Ingenting. Jag testade med en coroutine som bara kastar: `run()` returnerade normalt, programmet avslutade med kod 0, och inte ett ord skrevs ut. `detached` betyder "jag vill inte veta", och det gäller även fel. Det är därför varje server-coroutine i repot har try/catch runt sin loop. Vill man ha ut felet ger man `co_spawn` en riktig completion handler i stället, och det är så klienterna gör.

* * *

Daytime-klienten: tre rader igen
--------------------------------

Här är löftet från förra delen infriat. Resolve, connect, read, som var tre nästlade lambdas med varsin felkontroll:

```cpp
auto daytime(std::string host, std::string port) -> awaitable<void> {
    auto ex = co_await asio::this_coro::executor;
    auto resolver = tcp::resolver{ex};
    auto socket = tcp::socket{ex};
    auto reply = std::string{};

    auto endpoints = co_await resolver.async_resolve(host, port);
    auto ep = co_await asio::async_connect(socket, endpoints);
    std::println("ansluten till {}", to_string(ep));

    auto [ec, n] = co_await asio::async_read(socket, asio::dynamic_buffer(reply), asio::as_tuple);
    if (ec && ec != asio::error::eof) throw boost::system::system_error{ec, "read"};

    std::print("svar: {}", reply);
}
```

Tre `co_await` i följd, och koden läses uppifrån och ned som den synkrona klienten i del 1. Resultatet av varje steg är ett returvärde, inte ett argument till nästa lambda. Felkontrollen är borta ur två av tre steg, för ett fel i resolve eller connect kastar, och det räcker. Och `status`\-variabeln, som förra delen behövde för att få ut en felkod ur en lambda, är borta ur coroutinen. I stället fångas felet där coroutinen startas:

```cpp
asio::co_spawn(ioc, daytime(host, port), [&status](std::exception_ptr e) {
    if (!e) return;
    try {
        std::rethrow_exception(e);
    } catch (std::exception const& ex) {
        std::println(stderr, "fel: {}", ex.what());
        status = 1;
    }
});

ioc.run();
return status;
```

Det här är `co_spawn` med en riktig completion handler i stället för `detached`. Handlern körs när coroutinen är klar, med ett `std::exception_ptr` som är tomt om allt gick bra. Det är enda stället där ett exception från en coroutine fångas utanför den, och det är det `detached` hoppar över. Raden `co_await asio::this_coro::executor` är ett litet trick för att få tag i den executor coroutinen körs på, så att I/O-objekten kan skapas inne i coroutinen utan att `ioc` skickas in som argument.

Mot daytime-servern från del 1 ger det samma svar som förut. Mot en stängd port:

```text
$ ./build/release/daytime-client/daytime-client localhost 9999
fel: Connection refused [system:111]
```

En detalj: de synkrona anropen i del 1 gav "connect: Connection refused", med operationens namn. Ett kastande `co_await` ger bara "Connection refused". Vill man ha prefixet får man fånga och kasta om, eller använda `as_tuple` och formatera själv. Jag lät det vara.

* * *

Chattserver, steg 3: coroutines i en tråd
-----------------------------------------

Chattservern behåller sin tredelning från förra delen, men `Server`\-klassen har blivit en `listener()`\-funktion precis som i echo-servern, och `Room` är oförändrad från steg 2a: ett `std::set` av sessioner, `join`, `leave` och `broadcast`, ingen mutex, för allt körs i en tråd. Det nya är `Session`, som nu består av två coroutines:

```text
reader():  for(;;) { co_await async_read_until en rad; room.broadcast() }
writer():  for(;;) { vänta tills kön har något; co_await async_write ett meddelande }
```

Läsaren är det du väntar dig:

```cpp
auto reader() -> awaitable<void> {
    try {
        for (;;) {
            auto n = co_await asio::async_read_until(socket, asio::dynamic_buffer(read_buf), '\n');
            auto line = strip_eol(std::string_view{read_buf}.substr(0, n));
            room.broadcast(std::format("[{}] {}\n", name, line), super::shared_from_this());
            read_buf.erase(0, n);
        }
    } catch (boost::system::system_error const&) {
        // eof, eller operation_aborted när writer() stängt socketen
    }
    close();
}
```

Skrivaren är det intressanta. I förra delen var skrivkön `deliver()` plus `do_write()` plus en skriv-handler som tog nästa ur kön, och ett `in_flight`\-fält som höll meddelandet under skrivning utanför kön så att trimningen aldrig kunde röra det. Nu är skrivaren en coroutine med en loop, och frågan är hur den ska _vänta_ när kön är tom. Det finns ingen operation att `co_await`:a, för det som ska hända är att någon annan session anropar `deliver()`. Svaret, som är hämtat från Asios eget chat-exempel, är en timer som aldrig går av:

```cpp
asio::steady_timer timer;  // väckarklocka för writer(), går aldrig av
// ... i konstruktorn:
timer.expires_at(asio::steady_timer::time_point::max());

void deliver(std::string msg) {
    if (is_full()) {
        queue.pop_front();
        ++dropped;
    }
    queue.push_back(std::move(msg));
    timer.cancel_one();
}

auto writer() -> awaitable<void> {
    try {
        while (socket.is_open()) {
            if (queue.empty()) {
                co_await timer.async_wait(asio::as_tuple);
                continue;
            }
            auto msg = std::move(queue.front());  // lokal: lever tills skrivningen är klar
            queue.pop_front();
            co_await asio::async_write(socket, asio::buffer(msg));
        }
    } catch (boost::system::system_error const&) {
        // skrivfel, eller operation_aborted när reader() stängt socketen
    }
    close();
}
```

När kön är tom väntar `writer()` på timern, som har sin utgångstid satt till oändligt långt fram. `deliver()` lägger meddelandet i kön och anropar `timer.cancel_one()`, som avbryter exakt en väntande `async_wait` med `operation_aborted`. Det är inte ett fel, det är signalen, och därför `as_tuple`: resultatet blir en tuple som vi inte ens tittar på, och loopen går ett varv till, ser att kön inte är tom, och skriver. En coroutine som väntar på en signal från vanlig kod, med bara kärn-Asio. Det finns en `experimental::channel` också, men timern räcker och är inte experimentell.

Lägg märke till `msg`. Meddelandet som skrivs är en lokal variabel i `writer()`, och lever i coroutinens frame tills `co_await async_write` är klart. Förra delens `in_flight` finns inte, för den fallgropen, att trimningen vid fullt tak frigör en buffert som en pågående skrivning läser från, kan inte uppstå när bufferten inte ligger i kön. Själva kön, taket på 1000 och kasta-äldst är oförändrade.

Till sist ägarskapet, för här kommer det tillbaka. `Session` är fortfarande `enable_shared_from_this`, trots att echo-servern klarade sig utan. Skillnaden är att två saker delar objektet: `Room` håller en `shared_ptr` i sin mängd, och de två coroutinerna använder samma socket, kö och timer. `start()` startar dem så här:

```cpp
void start() {
    auto self = super::shared_from_this();
    room.join(self);
    std::println("ansluten: {} ({} totalt)", name, room.size());
    room.broadcast(std::format("*** {} anslöt\n", name), self);

    co_spawn(socket.get_executor(), [self] { return self->reader(); }, detached);
    co_spawn(socket.get_executor(), [self] { return self->writer(); }, detached);
}
```

`co_spawn` tar här en lambda som returnerar coroutinen, och håller lambdan vid liv tills coroutinen är klar. Lambdan fångar `self`, så sessionen lever så länge någon av de två kör. Det är samma `shared_ptr`\-mekanik som i förra delen, men ägarna är nu två coroutines i stället för en kedja av handlers. Regeln är enkel: så fort två saker delar ett objekt är ägarskap tillbaka, coroutines eller inte.

`close()` är idempotent som förut. Den första coroutinen som kommer dit stänger socketen och avbryter timern, vilket får den andras pågående operation att ge `operation_aborted`. Den avslutar också och anropar `close()`, som då returnerar direkt eftersom socketen redan är stängd. Hela `Session` är knappt hundra rader, och finns i repot.

> Servern körs i en tråd, med ett enda `ioc.run()`. Vill du köra `run()` i flera trådar som i steg 2b fungerar strand:arna likadant med coroutines: `co_spawn(asio::make_strand(ioc), ...)` för varje session, så körs allt i den coroutinen på den strand:en, och rummet får posta till sin egen strand precis som förut. Jag lämnar det i en tråd här, så att fokus ligger på syntaxen.

### Samma resultat som förut

Två `nc` chattar som i förra delen, och simulatorn med 200 klienter visar en tråd. Head-of-line-experimentet, med en klient som slutat läsa, en `nc` som läser och 40 000 rader från en tredje, ger samma resultat som i steg 2a: den vakna får alla rader, och den pausade loggas när den kopplar ned:

```text
nedkopplad: 127.0.0.1:33264 (1 kvar, kastade 24372 meddelanden)
```

Inget nytt, och det är poängen. Servern beter sig exakt som förra delens, med samma garantier och samma prestanda. Det som ändrats är hur koden ser ut.

* * *

En egen klient
--------------

Hittills har `nc` varit klient, och det har räckt. Men en chattklient måste göra två saker samtidigt: läsa rader från tangentbordet och skicka dem, och läsa rader från servern och skriva ut dem. Synkront hade det krävt två trådar. Med coroutines är det två coroutines, och en operator:

```cpp
auto stdin_to_socket(asio::posix::stream_descriptor& in, tcp::socket& socket) -> awaitable<void> {
    auto line = std::string{};
    try {
        for (;;) {
            auto n = co_await asio::async_read_until(in, asio::dynamic_buffer(line), '\n');
            co_await asio::async_write(socket, asio::buffer(line, n));
            line.erase(0, n);
        }
    } catch (boost::system::system_error const& e) {
        if (e.code() != asio::error::eof) throw;
        std::println("(stdin stängd, avslutar)");  // Ctrl-D
    }
}

auto socket_to_stdout(tcp::socket& socket) -> awaitable<void> {
    auto buf = std::string{};
    try {
        for (;;) {
            auto n = co_await asio::async_read_until(socket, asio::dynamic_buffer(buf), '\n');
            std::print("{}", std::string_view{buf}.substr(0, n));
            std::fflush(stdout);
            buf.erase(0, n);
        }
    } catch (boost::system::system_error const& e) {
        if (e.code() != asio::error::eof) throw;
        std::println("(servern stängde)");
    }
}

auto chat(std::string host, std::string port) -> awaitable<void> {
    auto ex = co_await asio::this_coro::executor;
    auto resolver = tcp::resolver{ex};
    auto socket = tcp::socket{ex};
    auto in = asio::posix::stream_descriptor{ex, ::dup(STDIN_FILENO)};

    co_await asio::async_connect(socket, co_await resolver.async_resolve(host, port));
    std::println("ansluten till {}:{}, skriv rader, Ctrl-D avslutar", host, port);

    co_await (stdin_to_socket(in, socket) || socket_to_stdout(socket));
}
```

Två nya saker. Den första är `posix::stream_descriptor`, Asios I/O-objekt för en vanlig filbeskrivare. Det är första gången i serien som Asio läser något annat än en socket, och det fungerar likadant: `async_read_until` på stdin, med samma `dynamic_buffer` och samma `co_await`. `dup()` är för att destruktorn ska stänga en kopia och inte processens riktiga stdin. Klassen finns på Linux och macOS, inte på Windows.

Den andra är sista raden. Operatorn `||` tar två awaitables och kör dem _parallellt_, i samma tråd, och blir klar när den första av dem är klar. Den andra avbryts. Trycker du Ctrl-D tar stdin slut, `stdin_to_socket()` avslutar, och `socket_to_stdout()`, som står och väntar i `async_read_until`, får sin operation avbruten och avslutar också. Dör servern i stället händer samma sak åt andra hållet. I båda fallen returnerar `chat()`, och programmet avslutar snyggt. Operatorerna ligger i `boost/asio/experimental/awaitable_operators.hpp` och kräver ett `using namespace`, och det finns en `&&` också, som väntar på båda.

Servern i en terminal, klienten i en andra, en `nc` i en tredje:

```text
$ ./build/release/chatclient/chatclient
ansluten till localhost:4711, skriv rader, Ctrl-D avslutar
hej från chatclient
[127.0.0.1:60366] hej från nc
[127.0.0.1:60366] hej igen
(stdin stängd, avslutar)
```

* * *

Timeouts
--------

Samma operator löser ett problem som ingen av de tidigare delarna rört: timeouts. En synkron `connect()` kan hänga i minuter mot en adress som inte svarar, och en asynkron likaså, om ingen avbryter den. Med `||` är en timeout en timer som tävlar mot operationen. Här är daytime-klienten igen, med tre sekunders tidsgräns på connect och på read:

```cpp
constexpr auto timeout = 3s;
auto constexpr TIMEOUT = 1;
//...
timer.expires_after(timeout);
auto connected = co_await (asio::async_connect(socket, endpoints, asio::use_awaitable)
                        || timer.async_wait(asio::use_awaitable));
if (connected.index() == TIMEOUT)
    throw std::runtime_error{std::format("connect: timeout efter {}", timeout)};
std::println("ansluten till {}", to_string(std::get<0>(connected)));

timer.expires_after(timeout);
auto received = co_await (asio::async_read(socket, asio::dynamic_buffer(reply), asio::as_tuple(asio::use_awaitable))
                          || timer.async_wait(asio::use_awaitable));
if (received.index() == TIMEOUT)
    throw std::runtime_error{std::format("read: timeout efter {}", timeout)};
auto [ec, n] = std::get<0>(received);
```

Resultatet av `||` är en `std::variant` med ett alternativ per sida, och `index()` säger vem som vann: 0 är operationen, 1 är timern, därav konstanten `TIMEOUT`. Vinner timern avbryts anslutningsförsöket, och vi kastar. Vinner anslutningen avbryts timern, och vi fortsätter med dess resultat i `std::get<0>`.

Och så sa jag att det inte behövs några tokens i coroutine-kod, och här står `use_awaitable` på fyra ställen. Det är undantaget. Operatorerna är definierade för `awaitable<T>`, inte för deferred-objekt. Ett anrop utan token går att `co_await`:a, men inte att sätta på en sida om `||`. Mitt första försök utan tokens gav ett kompilatorfel på ett dussin rader, som kokade ned till att `deferred_async_operation` inte är en `awaitable`. I klienten behövdes inget, för där var operanderna egna coroutines, som _är_ awaitables. Vill man ha operationer direkt i uttrycket får `use_awaitable` skrivas ut, och `as_tuple` får ta den som argument.

Mot `nc -l 1313`, som accepterar anslutningen men aldrig skickar något, och mot en adress som inte svarar:

```text
$ ./build/release/daytime-timeout/daytime-timeout
ansluten till 127.0.0.1:1313
fel: read: timeout efter 3s

$ ./build/release/daytime-timeout/daytime-timeout 10.255.255.1
fel: connect: timeout efter 3s
```

> **För dig som kan Node.js.** Nu går det att sätta upp en ordentlig mappning.
> 
> Node.js
> 
> Boost.Asio
> 
> `net.createServer(handler)`
> 
> `tcp::acceptor` + `listener()` + `co_spawn`
> 
> `async function`
> 
> `awaitable<T>`
> 
> `for await (const chunk of socket)`
> 
> `co_await async_read_some()`
> 
> `setTimeout`
> 
> `steady_timer`
> 
> `Promise.race([a, b])`
> 
> `a || b`
> 
> `Promise.all([a, b])`
> 
> `a && b`
> 
> `AbortController` / `AbortSignal`
> 
> `cancellation_signal` / `cancellation_slot`
> 
> Den stora skillnaden är fortfarande eager mot lazy. `Promise.race` tar Promises som redan kör, och förloraren fortsätter köra i bakgrunden om du inte avbryter den själv med en `AbortController`. Asios `||` startar båda sidorna, och avbryter förloraren åt dig. Det leder över till nästa avsnitt.

* * *

Utblick
-------

Tre saker som den här artikeln bara snuddar vid, och som du kommer att stöta på.

**Cancellation.** När `||` avbröt förloraren använde den Asios stöd för _per-operation cancellation_, som kom i Boost 1.77. Varje asynkron operation kan kopplas till en `cancellation_slot`, och när någon signalerar på den avbryts operationen med `operation_aborted`. Operatorn gör det åt dig, men du kan göra det själv: skapa en `cancellation_signal`, bind dess slot till en operation med `bind_cancellation_slot`, och anropa `emit()` när du vill avbryta. Det är vad som behövs för en "avbryt"-knapp eller en graceful shutdown, och det senare återkommer i nästa del. I de flesta fall räcker operatorerna.

**Stackful coroutines.** Asio hade coroutines långt före C++20, i form av `asio::spawn` med en `yield_context` som token. De bygger på Boost.Context, som byter stack i stället för att använda språkets coroutines, och biblioteket är inte header-only. Du ser dem i äldre kod och i äldre exempel, och de fungerar fortfarande. För ny kod är `awaitable` och `co_await` rätt val.

**Boost.Cobalt.** Sedan Boost 1.84 finns ett eget coroutine-bibliotek ovanpå Asio, med `task`, `promise`, `generator` och `channel`. Det är ett försök att göra coroutines enklare än Asios egna typer, med färre val och ett tydligare eager/lazy-tänk. Jag har inte använt det på riktigt än, och det kan hända att jag skriver om det längre fram. Inget löfte dock.

* * *

Sammanfattning
--------------

Callback och coroutine är samma API. Sista argumentet till varje `async_*`\-funktion är en completion token, och vi såg fyra av dem på samma `async_wait`: callback, `use_future`, `deferred` och `use_awaitable`. Sedan Boost 1.86 är `deferred` default, och eftersom en `awaitable` kan `co_await`:a ett deferred-objekt behövs nästan aldrig någon token alls i coroutine-kod.

Med coroutines blir den asynkrona koden synkron till formen. Echo-serverns kedja av handlers blev en `for`\-loop, och buffertar och sockets blev lokala variabler igen, eftersom de lever i coroutinens frame. Daytime-klientens tre nivåer av lambdas blev tre `co_await` i följd, och fel kastas som exceptions i stället för att smugglas ut via en variabel. Exceptions som lämnar en coroutine hamnar i `co_spawn`:s completion handler, och med `detached` försvinner de tyst, så fånga dem.

Chattservern fick två coroutines per session, en läsare och en skrivare, med en timer som aldrig går av som väckarklocka för skrivkön. Den egna klienten läser från stdin och socketen samtidigt med två coroutines och operatorn `||`, som också ger timeouts: en timer som tävlar mot operationen, med en `std::variant` som resultat. Det är det enda stället där `use_awaitable` måste skrivas ut, för operatorerna tar bara awaitables.

Och allt det här, varenda `co_await`, är samma `io_context`, samma `run()` och samma strand:ar som i förra delen. Nästa del lämnar syntaxen och går på produktionsdetaljerna: TLS med `asio::ssl`, graceful shutdown med `signal_set` och cancellation, och UDP så att klienten hittar servern utan adress.
