Re: Fwd: Using ASIO to wait on a foreign socket being readable, with a timeout

From: Martijn Otto (boost_at_[hidden])
Date: 2024-01-18 19:19:19

ASIO will assume ownership of the socket, which means it'll close the
socket when it's destructed. If you don't want this, you have to call
`release()` on it before destructing.

That _might_ help, or it might not, ASIO might do different things to
the socket as well. Depending on the platform, it'll use different
techniques for waiting on the socket, might be epoll on linux, kqueue
on BSD (including mac), etc... In my experience, if it's a pipe, it'll
work with epoll on linux, but it might fail on BSD. YMMV.

On Thu, 2024-01-18 at 19:44 +0100, Dominique Devienne via Boost-users
wrote:
> Sorry, sent originally to the wrong list.
> And this is on Windows 10 too, BTW.
> Haven't tried Linux with that code yet. --DD
> 
> ---------- Forwarded message ---------
> From: Dominique Devienne <ddevienne_at_[hidden]>
> Date: Thu, Jan 18, 2024 at 7:18 PM
> Subject: Using ASIO to wait on a foreign socket being readable, with
> a timeout
> To: <boost_at_[hidden]>
> 
> 
> Hi,
> 
> I'm trying to use ASIO to wait until a socket is ready to read, or
> timeout.
> This is a blocking wait. But the socket is not "owned" by ASIO, but
> is from
> the libpq PostgreSQL connection. So ASIO should NOT consume any of
> the input on the socket, just notify me when that socket is "read-
> ready".
> 
> I've cobbled together the following test code:
> 
> ```
> Â  Â  const int socket2 =Â PQsocket(conn2.handle());
> Â  Â  BOOST_CHECK(socket2 > 0);
> 
> Â  Â  int timr_err_code = 0;
> Â  Â  int sock_err_code = 0;
> Â  Â  bool timr_aborted = false;
> Â  Â  bool sock_aborted = false;
> Â  Â  std::string timr_err_msg;
> Â  Â  std::string sock_err_msg;
> Â  Â  bool timed_out = true;
> 
> Â  Â  auto c1 = "C# 1"sv;
> Â  Â  conn2.listen(c1);
> Â  Â  conn1->notify(c1, "wake up!"sv);
> 
> Â  Â  {
> Â  Â  Â  Â  boost::asio::io_context io_ctx;
> Â  Â  Â  Â  boost::asio::ip::tcp::socket io_sock(io_ctx);
> Â  Â  Â  Â  io_sock.assign(boost::asio::ip::tcp::v4(), socket2);
> 
> Â  Â  Â  Â  boost::asio::steady_timer io_timer(io_ctx);
> Â  Â  Â  Â  io_timer.expires_from_now(std::chrono::milliseconds(100));
> Â  Â  Â  
> Â  Â  Â  Â  io_sock.async_wait(
> Â  Â  Â  Â  Â  Â  io_sock.wait_read,
> Â  Â  Â  Â  Â  Â  [&](const boost::system::error_code& errc) {
> Â  Â  Â  Â  Â  Â  Â  Â  if (errc) {
> Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  sock_err_code = errc.value();
> Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  sock_err_msg = errc.message();
> Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  sock_aborted = (errc ==
> boost::asio::error::operation_aborted);
> Â  Â  Â  Â  Â  Â  Â  Â  }
> Â  Â  Â  Â  Â  Â  Â  Â  timed_out = false;
> Â  Â  Â  Â  Â  Â  Â  Â  //io_timer.cancel();
> Â  Â  Â  Â  Â  Â  Â  Â  io_ctx.stop();
> Â  Â  Â  Â  Â  Â  }
> Â  Â  Â  Â  );
> 
> Â  Â  Â  Â  io_timer.async_wait(
> Â  Â  Â  Â  Â  Â  [&](const boost::system::error_code& errc) {
> Â  Â  Â  Â  Â  Â  Â  Â  if (errc) {
> Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  timr_err_code = errc.value();
> Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  timr_err_msg = errc.message();
> Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  timr_aborted = (errc ==
> boost::asio::error::operation_aborted);
> Â  Â  Â  Â  Â  Â  Â  Â  }
> Â  Â  Â  Â  Â  Â  Â  Â  io_sock.cancel();
> Â  Â  Â  Â  Â  Â  Â  Â  io_ctx.stop();
> Â  Â  Â  Â  Â  Â  }
> Â  Â  Â  Â  );
> 
> Â  Â  Â  Â  io_ctx.run(); // blocks until either async op above runs
> Â  Â  }
> 
> Â  Â  // there's a notif to read, so io_sock.async_wait should have
> completed
> Â  Â  BOOST_CHECK_EQUAL(timr_err_code, 0);
> Â  Â  BOOST_CHECK_EQUAL(sock_err_code, 0);
> Â  Â  BOOST_CHECK_EQUAL(timr_err_msg, "");
> Â  Â  BOOST_CHECK_EQUAL(sock_err_msg, "");
> Â  Â  BOOST_CHECK_EQUAL(timr_aborted, false);
> Â  Â  BOOST_CHECK_EQUAL(sock_aborted, false);
> Â  Â  BOOST_CHECK_EQUAL(timed_out, false);
> 
> Â  Â  auto notif = conn2.notification();
> Â  Â  BOOST_REQUIRE(notif);
> Â  Â  BOOST_CHECK_EQUAL(notif.backend_pid(), pid1);
> Â  Â  BOOST_CHECK_EQUAL(notif.channel(), c1);
> Â  Â  BOOST_CHECK_EQUAL(notif.payload(), "wake up!"sv);
> ```
> 
> The io_sock.async_wait(io_sock.wait_read, ...) succeeds,
> the IO loop stops as expected, but when I try to PQconsumeInput()
> from the LIBPQ connection next (as shown in the code below)
> 
> ```
> Notification Connection::notification() {
> Â  Â  auto [lock, hndl] = ensure_handle();
> Â  Â  if (1 != PQconsumeInput(hndl)) {
> Â  Â  Â  Â  throw std::runtime_error(error_msg()); // <<<<<< THROWS
> Â  Â  }
> Â  Â  PGnotify_uptr notif{ PQnotifies(hndl) };
> Â  Â  return Notification(std::move(notif)); // may be null
> }
> ```
> 
> that calls fail with this error message:
> 
> fatal error: in "NotificationTests/test_across_backends": class
> std::runtime_error: could not receive data from server: Socket
> operation on non-socket (0x00002736/10038)
> 
> LIBPQ didn't like what ASIO somehow did on the socket descriptor.
> The LIBPQ doc says to select() the descriptor, but I thought ASIO
> would be cleaner,
> more C++, and perhaps more cross-platform.
> 
> Can somehow help, telling me if I'm using ASIO incorrectly here?
> 
> Thanks, --DD
> 
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> https://lists.boost.org/mailman/listinfo.cgi/boost-users