TLA  Line data    Source code

       1                 : //
       2                 : // Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)
       3                 : // Copyright (c) 2026 Steve Gerbino
       4                 : //
       5                 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       6                 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       7                 : //
       8                 : // Official repository: https://github.com/cppalliance/corosio
       9                 : //
      10                 : 
      11                 : #ifndef BOOST_COROSIO_TEST_SOCKET_PAIR_HPP
      12                 : #define BOOST_COROSIO_TEST_SOCKET_PAIR_HPP
      13                 : 
      14                 : #include <boost/corosio/io_context.hpp>
      15                 : #include <boost/corosio/tcp_acceptor.hpp>
      16                 : #include <boost/corosio/tcp_socket.hpp>
      17                 : #include <boost/corosio/socket_option.hpp>
      18                 : #include <boost/capy/ex/run_async.hpp>
      19                 : #include <boost/capy/task.hpp>
      20                 : 
      21                 : #include <cstdio>
      22                 : #include <stdexcept>
      23                 : #include <system_error>
      24                 : #include <utility>
      25                 : 
      26                 : namespace boost::corosio::test {
      27                 : 
      28                 : /** Create a connected pair of sockets.
      29                 : 
      30                 :     Creates two sockets connected via loopback TCP sockets.
      31                 :     Data written to one socket can be read from the other.
      32                 : 
      33                 :     @tparam Socket The socket type (default `tcp_socket`).
      34                 :     @tparam Acceptor The acceptor type (default `tcp_acceptor`).
      35                 :     @tparam Linger Whether to enable `SO_LINGER` with a zero timeout
      36                 :         on both sockets (default `true`).
      37                 : 
      38                 :     @param ctx The I/O context for the sockets.
      39                 : 
      40                 :     @return A pair of connected sockets.
      41                 : 
      42                 :     @throws std::runtime_error if opening, binding, listening,
      43                 :         accepting, or connecting fails.
      44                 : */
      45                 : template<
      46                 :     class Socket   = tcp_socket,
      47                 :     class Acceptor = tcp_acceptor,
      48                 :     bool Linger    = true>
      49                 : std::pair<Socket, Socket>
      50 HIT         260 : make_socket_pair(io_context& ctx)
      51                 : {
      52             260 :     auto ex = ctx.get_executor();
      53                 : 
      54             260 :     std::error_code accept_ec;
      55             260 :     std::error_code connect_ec;
      56             260 :     bool accept_done  = false;
      57             260 :     bool connect_done = false;
      58                 : 
      59             260 :     Acceptor acc(ctx);
      60             260 :     if (auto open_ec = acc.open())
      61 MIS           0 :         throw std::runtime_error(
      62                 :             "socket_pair open failed: " + open_ec.message());
      63 HIT         260 :     acc.set_option(socket_option::reuse_address(true));
      64             260 :     if (auto ec = acc.bind(endpoint(ipv4_address::loopback(), 0)))
      65 MIS           0 :         throw std::runtime_error("socket_pair bind failed: " + ec.message());
      66 HIT         260 :     if (auto ec = acc.listen())
      67 MIS           0 :         throw std::runtime_error("socket_pair listen failed: " + ec.message());
      68 HIT         260 :     auto port = acc.local_endpoint().port();
      69                 : 
      70             260 :     Socket s1(ctx);
      71             260 :     Socket s2(ctx);
      72             260 :     if (auto open_ec = s2.open())
      73 MIS           0 :         throw std::runtime_error(
      74                 :             "socket_pair open failed: " + open_ec.message());
      75                 : 
      76 HIT         260 :     capy::run_async(ex)(
      77             520 :         [](Acceptor& a, Socket& s, std::error_code& ec_out,
      78                 :            bool& done_out) -> capy::task<> {
      79                 :             auto [ec] = co_await a.accept(s);
      80                 :             ec_out    = ec;
      81                 :             done_out  = true;
      82                 :         }(acc, s1, accept_ec, accept_done));
      83                 : 
      84             520 :     capy::run_async(ex)(
      85             260 :         [](Socket& s, endpoint ep, std::error_code& ec_out,
      86                 :            bool& done_out) -> capy::task<> {
      87                 :             auto [ec] = co_await s.connect(ep);
      88                 :             ec_out    = ec;
      89                 :             done_out  = true;
      90             520 :         }(s2, endpoint(ipv4_address::loopback(), port), connect_ec,
      91                 :                            connect_done));
      92                 : 
      93             260 :     ctx.run();
      94             260 :     ctx.restart();
      95                 : 
      96             260 :     if (!accept_done || accept_ec)
      97                 :     {
      98 MIS           0 :         std::fprintf(
      99                 :             stderr, "socket_pair: accept failed (done=%d, ec=%s)\n",
     100                 :             accept_done, accept_ec.message().c_str());
     101               0 :         acc.close();
     102               0 :         throw std::runtime_error("socket_pair accept failed");
     103                 :     }
     104                 : 
     105 HIT         260 :     if (!connect_done || connect_ec)
     106                 :     {
     107 MIS           0 :         std::fprintf(
     108                 :             stderr, "socket_pair: connect failed (done=%d, ec=%s)\n",
     109                 :             connect_done, connect_ec.message().c_str());
     110               0 :         acc.close();
     111               0 :         s1.close();
     112               0 :         throw std::runtime_error("socket_pair connect failed");
     113                 :     }
     114                 : 
     115 HIT         260 :     acc.close();
     116                 : 
     117                 :     if constexpr (Linger)
     118                 :     {
     119              93 :         s1.set_option(socket_option::linger(true, 0));
     120              93 :         s2.set_option(socket_option::linger(true, 0));
     121                 :     }
     122                 : 
     123             520 :     return {std::move(s1), std::move(s2)};
     124             260 : }
     125                 : 
     126                 : } // namespace boost::corosio::test
     127                 : 
     128                 : #endif