Boost.Asio async_read a string from a socket

Question

I'm trying to write a function async_read_string_n to asynchronously read a string of exactly n bytes from a socket with Boost.Asio 1.78 (and GCC 11.2).

This is how I want to use the function async_read_string_n:

void run() {
  co_spawn (io_context_, [&]() -> awaitable<void> {
    auto executor = io_context_.get_executor();
    tcp::acceptor acceptor(executor, listen_endpoint_);

    auto [ec, socket] = co_await acceptor.async_accept(as_tuple(use_awaitable));
    co_spawn(executor, [&]() -> awaitable<void> {

      auto [ec, header] = co_await async_read_string_n(socket, 6, as_tuple(use_awaitable));
      std::cerr << "received string " << header << "\n";
      co_return;
    }
    , detached);
    co_return;
  }
  , detached);
}
  

Here is my attempt to write async_read_string_n, following the advice in

• https://www.boost.org/doc/libs/1_78_0/doc/html/boost_asio/reference/asynchronous_operations.html#boost_asio.reference.asynchronous_operations.automatic_deduction_of_initiating_function_return_type
• https://www.boost.org/doc/libs/1_78_0/doc/html/boost_asio/overview/core/cpp20_coroutines.html#boost_asio.overview.core.cpp20_coroutines.error_handling

(I don't care about memory copying. This isn't supposed to be fast; it's supposed to have a nice API.)

template<class CompletionToken> auto async_read_string_n(tcp::socket& socket, int n, CompletionToken&& token) {
  async_completion<CompletionToken, void(boost::system::error_code, std::string)> init(token);
  asio::streambuf b;
  asio::streambuf::mutable_buffers_type bufs = b.prepare(n);
  auto [ec, bytes_transferred] = co_await asio::async_read(socket, bufs, asio::transfer_exactly(n), as_tuple(use_awaitable));
  b.commit(n);
  std::istream is(&b);
  std::string s;
  is >> s;
  b.consume(n);
  init.completion_handler(ec, s);
  return init.result.get();
}

Edit

(I had a syntax error and I fixed it.) Here is the compiler error in async_read_string_n which I'm stuck on:

GCC error:

error: 'co_await' cannot be used in a function with a deduced return type

How can I write the function async_read_string_n?

Answer 1

You don't have to use streambuf. Regardless, using the >> extraction will not reliably extract the string (whitespace stops the input).

The bigger problem is that you have to choose whether you want to use

• co_await (which requires another kind of signature as your second link correctly shows)
• or the async result protocol, which implies that the caller will decide what mechanism to use (a callback, future, group, awaitable etc).

So either make it:

Using Async Result Protocol:

#include <boost/asio.hpp>
#include <boost/asio/awaitable.hpp>
#include <boost/asio/experimental/as_tuple.hpp>
#include <boost/asio/use_awaitable.hpp>
#include <iostream>
#include <iomanip>
namespace net = boost::asio;
using net::ip::tcp;
using boost::system::error_code;

template <typename CompletionToken>
auto async_read_string_n(tcp::socket& socket, int n, CompletionToken&& token)
{
    struct Op {
        net::async_completion<CompletionToken, void(error_code, std::string)>
            init;
        std::string buf;
        Op(CompletionToken token) : init(token) {}
    };
    auto op = std::make_shared<Op>(token);

    net::async_read(socket, net::dynamic_buffer(op->buf),
                    net::transfer_exactly(n), [op](error_code ec, size_t n) {
                        op->init.completion_handler(ec, std::move(op->buf));
                    });
    return op->init.result.get();
}

int main() {
    net::io_context ioc;
    tcp::socket s(ioc);
    s.connect({{}, 8989});

    async_read_string_n(s, 10, [](error_code ec, std::string s) {
        std::cout << "Read " << ec.message() << ": " << std::quoted(s)
                  << std::endl;
    });

    ioc.run();
}

Prints

NOTE This version affords you the calling semantics that you desire in your sample run() function.

OR Use co_await

Analogous to the sample here:

boost::asio::awaitable<void> echo(tcp::socket socket)
{
  char data[1024];
  for (;;)
  {
    auto [ec, n] = co_await socket.async_read_some(boost::asio::buffer(data),
        boost::asio::experimental::as_tuple(boost::asio::use_awaitable));
    if (!ec)
    {
      // success
    }

    // ...
  }
}

Answer 2

Thank you @sehe for your answer, which gave me the information I needed to write async_read_string_n which works with co_await:

asio::awaitable<std::tuple<boost::system::error_code, std::string>> async_read_string_n(tcp::socket& socket, int n) {
  std::string buf;
  auto [ec, bytes_transferred] = co_await asio::async_read(socket, asio::dynamic_buffer(buf), asio::transfer_exactly(n), as_tuple(use_awaitable));
  co_return make_tuple(ec, buf);
}

Use it like this:

auto [ec, string6] = co_await async_read_string_n(socket, 6);

I wrote a post about this: https://github.com/xc-jp/blog-posts/blob/master/Asio-Coroutines.md