BOOST async_receive 当套接字关闭时不返回

huangapple
go评论95阅读模式
英文:

BOOST async_receive doesn't return when socket is closed

问题

  1. 我正在尝试使用 *boost.asio* 编写一个简单的客户端/服务器程序。
  2. 我的问题是，当客户端关闭其套接字并退出时，“stream.async_receive()”会阻塞服务器端并且不返回。
  4. 这是我的代码：
英文:

I'm trying to write a simple client/server program using boost.asio.
My problem is that when the client closes it's socket and exits, "stream.async_receive()" blocks the server side and doesn't return.

Here's my code:

  1. #include <boost/asio/co_spawn.hpp>
  2. #include <boost/asio/detached.hpp>
  3. #include <boost/asio/io_service.hpp>
  4. #include <boost/asio/ip/tcp.hpp>
  5. #include <boost/asio/awaitable.hpp>
  6. #include <boost/asio.hpp>
  7. #include <string>
  8. #include <iostream>
  10. using namespace std;
  11. namespace asio = boost::asio;
  12. using namespace boost::asio::ip;
  14. asio::awaitable<void> handle_connection(tcp::socket&& stream)
  15. {
  16.     std::cout << "new connection\n";
  17.     std::string buffer;
  18.     uint64_t buffer_size;
  20.     while(stream.is_open())
  21.     {
  22.         co_await stream.async_receive(asio::buffer(&buffer_size, 8), asio::use_awaitable);
  23.         buffer = std::string(buffer_size, '
    #include <boost/asio/co_spawn.hpp>
  24. #include <boost/asio/detached.hpp>
  25. #include <boost/asio/io_service.hpp>
  26. #include <boost/asio/ip/tcp.hpp>
  27. #include <boost/asio/awaitable.hpp>
  28. #include <boost/asio.hpp>
  29. #include <string>
  30. #include <iostream>
  31. using namespace std;
  32. namespace asio = boost::asio;
  33. using namespace boost::asio::ip;
  34. asio::awaitable<void> handle_connection(tcp::socket&& stream)
  35. {
  36. std::cout << "new connection\n";
  37. std::string buffer;
  38. uint64_t buffer_size;
  39. while(stream.is_open())
  40. {
  41. co_await stream.async_receive(asio::buffer(&buffer_size, 8), asio::use_awaitable);
  42. buffer = std::string(buffer_size, '\0');
  43. std::cout << "message size: " << buffer_size << "\n";
  44. co_await stream.async_receive(asio::buffer(buffer, buffer_size), asio::use_awaitable);
  45. std::cout << "new message: " << buffer << "\n";
  46. }
  47. // The program never reached this point.
  48. cout << "socket closed\n";
  49. co_return;
  50. }
  51. asio::awaitable<void> accept_connection()
  52. {
  53. auto ex = co_await asio::this_coro::executor;
  54. boost::asio::ip::tcp::acceptor acceptor(ex, {{}, 8000});
  55. tcp::socket sock = co_await acceptor.async_accept(asio::use_awaitable);
  56. while(true)
  57. {
  58. co_spawn(ex, handle_connection(std::move(sock)), asio::detached);
  59. sock = co_await acceptor.async_accept(asio::use_awaitable);
  60. }
  61. co_return;
  62. }
  63. int main()
  64. {
  65. asio::io_context io_ctx(2);
  66. co_spawn(io_ctx, accept_connection(), asio::detached);
  67. io_ctx.run();
  68. }
  69. ');
  70.         std::cout << "message size: " << buffer_size << "\n";
  71.         co_await stream.async_receive(asio::buffer(buffer, buffer_size), asio::use_awaitable);
  72.         std::cout << "new message: " << buffer << "\n";
  73.     }
  74.     // The program never reached this point.
  75.     cout << "socket closed\n";
  76.     co_return;
  77. }
  79. asio::awaitable<void> accept_connection()
  80. {
  81.     auto ex = co_await asio::this_coro::executor;
  82.     boost::asio::ip::tcp::acceptor acceptor(ex, {{}, 8000});
  84.     tcp::socket sock = co_await acceptor.async_accept(asio::use_awaitable);
  85.     while(true)
  86.     {
  87.         co_spawn(ex, handle_connection(std::move(sock)), asio::detached);
  88.         sock = co_await acceptor.async_accept(asio::use_awaitable);
  89.     }
  91.     co_return;
  92. }
  94. int main()
  95. {
  96.     asio::io_context io_ctx(2);
  97.     co_spawn(io_ctx, accept_connection(), asio::detached);
  98.     io_ctx.run();
  99. }

Any help would be much appreciated.

答案1

得分: 3

以下是您要求翻译的代码部分：

  1. Your loop exits. By exception. Because you you don't handle the exception you don't see it.
  3. To show you three ways in which to handle the errors (including Eof):
  5. asio::awaitable<void> handle_connection(tcp::socket stream) {
  6.     std::cout << "new connection" << std::endl;
  8.     for (std::string buffer; true;)
  9.         try {
  10.             boost::endian::big_uint64_t buffer_size[1];
  11.             co_await stream.async_receive(asio::buffer(buffer_size), use_awaitable);
  12.             buffer.assign(*buffer_size, '
    Your loop exits. By exception. Because you you don't handle the exception you don't see it.
  13. To show you three ways in which to handle the errors (including Eof):
  14. asio::awaitable<void> handle_connection(tcp::socket stream) {
  15. std::cout << "new connection" << std::endl;
  16. for (std::string buffer; true;)
  17. try {
  18. boost::endian::big_uint64_t buffer_size[1];
  19. co_await stream.async_receive(asio::buffer(buffer_size), use_awaitable);
  20. buffer.assign(*buffer_size, '\0');
  21. std::cout << "message size: " << *buffer_size << "" << std::endl;
  22. auto [ec, n] =
  23. co_await stream.async_receive(asio::buffer(buffer), as_tuple(use_awaitable));
  24. if (n) {
  25. buffer.resize(n);
  26. std::cout << "new message: " << buffer << "" << std::endl;
  27. }
  28. if (ec) {
  29. std::cout << "socket closed (ec: " << ec.message() << ")" << std::endl;
  30. break;
  31. }
  32. } catch (boost::system::system_error const& se) {
  33. std::cout << "socket closed (thrown ec: " << se.code().message() << ")" << std::endl;
  34. break;
  35. } catch (std::exception const& e) {
  36. std::cout << "socket closed (exception: " << e.what() << ")" << std::endl;
  37. break;
  38. }
  39. }
  40. ');
  41.             std::cout << "message size: " << *buffer_size << "" << std::endl;
  42.             auto [ec, n] =
  43.                 co_await stream.async_receive(asio::buffer(buffer), as_tuple(use_awaitable));
  45.             if (n) {
  46.                 buffer.resize(n);
  47.                 std::cout << "new message: " << buffer << "" << std::endl;
  48.             }
  50.             if (ec) {
  51.                 std::cout << "socket closed (ec: " << ec.message() << ")" << std::endl;
  52.                 break;
  53.             }
  54.         } catch (boost::system::system_error const& se) {
  55.             std::cout << "socket closed (thrown ec: " << se.code().message() << ")" << std::endl;
  56.             break;
  57.         } catch (std::exception const& e) {
  58.             std::cout << "socket closed (exception: " << e.what() << ")" << std::endl;
  59.             break;
  60.         }
  61. }
  1. I'd suggest sticking to the `error_code` approach, as it is the only approach (with C++20 coro's) that allows you to gracefully handle partial success (e.g. when the connection is lost half-way receiving the expected bytes). 
  3. > _Whether partial success makes sense depends on your application. Note that if handled without caution this (dealing with unintended partial messages) may lead to security issues._
  1. #include <boost/asio.hpp>
  2. #include <boost/endian/arithmetic.hpp>
  3. #include <iostream>
  5. namespace asio = boost::asio;
  6. using asio::ip::tcp;
  7. using asio::use_awaitable;
  9. asio::awaitable<void> handle_connection(tcp::socket stream) {
  10.     auto tok = as_tuple(use_awaitable);
  11.     std::cout << "new connection" << std::endl;
  13.     boost::system::error_code ec;
  14.     for (std::string buffer;;) {
  15.         boost::endian::big_uint64_t buffer_size[1];
  16.         size_t n = 0;
  18.         tie(ec, std::ignore) = co_await stream.async_receive(asio::buffer(buffer_size), tok);
  19.         if (ec) break;
  21.         std::cout << "message size: " << *buffer_size << std::endl;
  22.         buffer.assign(*buffer_size, '
    #include <boost/asio.hpp>
  23. #include <boost/endian/arithmetic.hpp>
  24. #include <iostream>
  25. namespace asio = boost::asio;
  26. using asio::ip::tcp;
  27. using asio::use_awaitable;
  28. asio::awaitable<void> handle_connection(tcp::socket stream) {
  29. auto tok = as_tuple(use_awaitable);
  30. std::cout << "new connection" << std::endl;
  31. boost::system::error_code ec;
  32. for (std::string buffer;;) {
  33. boost::endian::big_uint64_t buffer_size[1];
  34. size_t n = 0;
  35. tie(ec, std::ignore) = co_await stream.async_receive(asio::buffer(buffer_size), tok);
  36. if (ec) break;
  37. std::cout << "message size: " << *buffer_size << std::endl;
  38. buffer.assign(*buffer_size, '\0');
  39. std::tie(ec, n) = co_await stream.async_receive(asio::buffer(buffer), tok);
  40. if (n) {
  41. buffer.resize(n);
  42. std::cout << "new message: " << buffer << std::endl;
  43. }
  44. if (ec) break;
  45. }
  46. std::cout << "socket closed (" << ec.message() << ")" << std::endl;
  47. }
  48. asio::awaitable<void> accept_connection() {
  49. auto ex = co_await asio::this_coro::executor;
  50. tcp::acceptor acceptor(ex, {{}, 8989});
  51. while (true) {
  52. co_spawn(
  53. ex,
  54. handle_connection(co_await acceptor.async_accept(make_strand(ex), use_awaitable)),
  55. asio::detached);
  56. }
  57. }
  58. int main() {
  59. asio::io_context io_ctx;
  60. co_spawn(io_ctx, accept_connection(), asio::detached);
  61. io_ctx.run();
  62. }
  63. ');
  65.         std::tie(ec, n) = co_await stream.async_receive(asio::buffer(buffer), tok);
  67.         if (n) {
  68.             buffer.resize(n);
  69.             std::cout << "new message: " << buffer << std::endl;
  70.         }
  72.         if (ec) break;
  73.     }
  74.     std::cout << "socket closed (" << ec.message() << ")" << std::endl;
  75. }
  77. asio::awaitable<void> accept_connection() {
  78.     auto ex = co_await asio::this_coro::executor;
  79.     tcp::acceptor acceptor(ex, {{}, 8989});
  81.     while (true) {
  82.         co_spawn(
  83.             ex,
  84.             handle_connection(co_await acceptor.async_accept(make_strand(ex), use_awaitable)),
  85.             asio::detached);
  86.     }
  87. }
  89. int main() {
  90.     asio::io_context io_ctx;
  91.     co_spawn(io_ctx, accept_connection(), asio::detached);
  92.     io_ctx.run();
  93. }

希望这对您有所帮助。如果您需要任何进一步的帮助，请随时提出。

英文:

Your loop exits. By exception. Because you you don't handle the exception you don't see it.

To show you three ways in which to handle the errors (including Eof):

  1. asio::awaitable&lt;void&gt; handle_connection(tcp::socket stream) {
  2.     std::cout &lt;&lt; &quot;new connection&quot; &lt;&lt; std::endl;
  4.     for (std::string buffer; true;)
  5.         try {
  6.             boost::endian::big_uint64_t buffer_size[1];
  7.             co_await stream.async_receive(asio::buffer(buffer_size), use_awaitable);
  8.             buffer.assign(*buffer_size, &#39;
    asio::awaitable&lt;void&gt; handle_connection(tcp::socket stream) {
  9. std::cout &lt;&lt; &quot;new connection&quot; &lt;&lt; std::endl;
  10. for (std::string buffer; true;)
  11. try {
  12. boost::endian::big_uint64_t buffer_size[1];
  13. co_await stream.async_receive(asio::buffer(buffer_size), use_awaitable);
  14. buffer.assign(*buffer_size, &#39;\0&#39;);
  15. std::cout &lt;&lt; &quot;message size: &quot; &lt;&lt; *buffer_size &lt;&lt; &quot;&quot; &lt;&lt; std::endl;
  16. auto [ec, n] =
  17. co_await stream.async_receive(asio::buffer(buffer), as_tuple(use_awaitable));
  18. if (n) {
  19. buffer.resize(n);
  20. std::cout &lt;&lt; &quot;new message: &quot; &lt;&lt; buffer &lt;&lt; &quot;&quot; &lt;&lt; std::endl;
  21. }
  22. if (ec) {
  23. std::cout &lt;&lt; &quot;socket closed (ec: &quot; &lt;&lt; ec.message() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  24. break;
  25. }
  26. } catch (boost::system::system_error const&amp; se) {
  27. std::cout &lt;&lt; &quot;socket closed (thrown ec: &quot; &lt;&lt; se.code().message() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  28. break;
  29. } catch (std::exception const&amp; e) {
  30. std::cout &lt;&lt; &quot;socket closed (exception: &quot; &lt;&lt; e.what() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  31. break;
  32. }
  33. }
  34. &#39;);
  35.             std::cout &lt;&lt; &quot;message size: &quot; &lt;&lt; *buffer_size &lt;&lt; &quot;&quot; &lt;&lt; std::endl;
  36.             auto [ec, n] =
  37.                 co_await stream.async_receive(asio::buffer(buffer), as_tuple(use_awaitable));
  39.             if (n) {
  40.                 buffer.resize(n);
  41.                 std::cout &lt;&lt; &quot;new message: &quot; &lt;&lt; buffer &lt;&lt; &quot;&quot; &lt;&lt; std::endl;
  42.             }
  44.             if (ec) {
  45.                 std::cout &lt;&lt; &quot;socket closed (ec: &quot; &lt;&lt; ec.message() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  46.                 break;
  47.             }
  48.         } catch (boost::system::system_error const&amp; se) {
  49.             std::cout &lt;&lt; &quot;socket closed (thrown ec: &quot; &lt;&lt; se.code().message() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  50.             break;
  51.         } catch (std::exception const&amp; e) {
  52.             std::cout &lt;&lt; &quot;socket closed (exception: &quot; &lt;&lt; e.what() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  53.             break;
  54.         }
  55. }

I'd suggest sticking to the error_code approach, as it is the only approach (with C++20 coro's) that allows you to gracefully handle partial success (e.g. when the connection is lost half-way receiving the expected bytes).

> Whether partial success makes sense depends on your application. Note that if handled without caution this (dealing with unintended partial messages) may lead to security issues.

Live On Coliru

  1. #include &lt;boost/asio.hpp&gt;
  2. #include &lt;boost/endian/arithmetic.hpp&gt;
  3. #include &lt;iostream&gt;
  5. namespace asio = boost::asio;
  6. using asio::ip::tcp;
  7. using asio::use_awaitable;
  9. asio::awaitable&lt;void&gt; handle_connection(tcp::socket stream) {
  10.     auto tok = as_tuple(use_awaitable);
  11.     std::cout &lt;&lt; &quot;new connection&quot; &lt;&lt; std::endl;
  13.     boost::system::error_code ec;
  14.     for (std::string buffer;;) {
  15.         boost::endian::big_uint64_t buffer_size[1];
  16.         size_t n = 0;
  18.         tie(ec, std::ignore) = co_await stream.async_receive(asio::buffer(buffer_size), tok);
  19.         if (ec) break;
  21.         std::cout &lt;&lt; &quot;message size: &quot; &lt;&lt; *buffer_size &lt;&lt; std::endl;
  22.         buffer.assign(*buffer_size, &#39;
    #include &lt;boost/asio.hpp&gt;
  23. #include &lt;boost/endian/arithmetic.hpp&gt;
  24. #include &lt;iostream&gt;
  25. namespace asio = boost::asio;
  26. using asio::ip::tcp;
  27. using asio::use_awaitable;
  28. asio::awaitable&lt;void&gt; handle_connection(tcp::socket stream) {
  29. auto tok = as_tuple(use_awaitable);
  30. std::cout &lt;&lt; &quot;new connection&quot; &lt;&lt; std::endl;
  31. boost::system::error_code ec;
  32. for (std::string buffer;;) {
  33. boost::endian::big_uint64_t buffer_size[1];
  34. size_t n = 0;
  35. tie(ec, std::ignore) = co_await stream.async_receive(asio::buffer(buffer_size), tok);
  36. if (ec) break;
  37. std::cout &lt;&lt; &quot;message size: &quot; &lt;&lt; *buffer_size &lt;&lt; std::endl;
  38. buffer.assign(*buffer_size, &#39;\0&#39;);
  39. std::tie(ec, n) = co_await stream.async_receive(asio::buffer(buffer), tok);
  40. if (n) {
  41. buffer.resize(n);
  42. std::cout &lt;&lt; &quot;new message: &quot; &lt;&lt; buffer &lt;&lt; std::endl;
  43. }
  44. if (ec) break;
  45. }
  46. std::cout &lt;&lt; &quot;socket closed (&quot; &lt;&lt; ec.message() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  47. }
  48. asio::awaitable&lt;void&gt; accept_connection() {
  49. auto ex = co_await asio::this_coro::executor;
  50. tcp::acceptor acceptor(ex, {{}, 8989});
  51. while (true) {
  52. co_spawn(
  53. ex,
  54. handle_connection(co_await acceptor.async_accept(make_strand(ex), use_awaitable)),
  55. asio::detached);
  56. }
  57. }
  58. int main() {
  59. asio::io_context io_ctx;
  60. co_spawn(io_ctx, accept_connection(), asio::detached);
  61. io_ctx.run();
  62. }
  63. &#39;);
  65.         std::tie(ec, n) = co_await stream.async_receive(asio::buffer(buffer), tok);
  67.         if (n) {
  68.             buffer.resize(n);
  69.             std::cout &lt;&lt; &quot;new message: &quot; &lt;&lt; buffer &lt;&lt; std::endl;
  70.         }
  72.         if (ec) break;
  73.     }
  74.     std::cout &lt;&lt; &quot;socket closed (&quot; &lt;&lt; ec.message() &lt;&lt; &quot;)&quot; &lt;&lt; std::endl;
  75. }
  77. asio::awaitable&lt;void&gt; accept_connection() {
  78.     auto ex = co_await asio::this_coro::executor;
  79.     tcp::acceptor acceptor(ex, {{}, 8989});
  81.     while (true) {
  82.         co_spawn(
  83.             ex,
  84.             handle_connection(co_await acceptor.async_accept(make_strand(ex), use_awaitable)),
  85.             asio::detached);
  86.     }
  87. }
  89. int main() {
  90.     asio::io_context io_ctx;
  91.     co_spawn(io_ctx, accept_connection(), asio::detached);
  92.     io_ctx.run();
  93. }

Testing with

  1. g++ -std=c++20 -Os -Wall -pedantic -pthread main.cpp;
  2. ./a.out&amp; sleep 1;
  3. printf &#39;\x00\x00\x00\x00\x00\x00\x00\x0cHello world!\x00\x00\x00\x00\x00\x00\x00\x03Bye&#39; | nc 127.0.0.1 8000 -w 1

Prints

  1. new connection
  2. message size: 12
  3. new message: Hello world!
  4. message size: 3
  5. new message: Bye
  6. socket closed (End of file)

Interactive:

BOOST async_receive 当套接字关闭时不返回

huangapple
  • 本文由 发表于 2023年2月23日 21:37:40
  • 转载请务必保留本文链接：https://go.coder-hub.com/75545587.html
  • boost
  • c++
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定