SO_RCVTIME和SO_RCVTIMEO不会影响Boost.Asio操作

时间：2015-05-23 07:44:48

标签： c++ linux boost boost-asio

以下是我的代码

boost::asio::io_service io;
boost::asio::ip::tcp::acceptor::reuse_address option(true);
boost::asio::ip::tcp::acceptor accept(io);
boost::asio::ip::tcp::resolver resolver(io);
boost::asio::ip::tcp::resolver::query query("0.0.0.0", "8080");
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
accept.open(endpoint.protocol());
accept.set_option(option);
accept.bind(endpoint);
accept.listen(30);

boost::asio::ip::tcp::socket ps(io);

accept.accept(ps);

struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;
//setsockopt(ps.native(), SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
setsockopt(ps.native(), SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
char buf[1024];
ps.async_receive(boost::asio::buffer(buf, 1024), boost::bind(fun));
io.run();

当我使用Telnet连接但不发送数据时，它不会与Telnet超时断开连接。是否需要设置setsockopt？ 谢谢！

我已将SO_RCVTIMEO修改为SO_SNDTIMEO。仍无法在指定时间内超时

2 个答案:

答案 0 :(得分：16)

在Boost.Asio中使用SO_RCVTIMEO和SO_SNDTIMEO套接字选项很少会产生所需的行为。请考虑使用以下两种模式之一：

使用async_wait()

进行组合操作

可以通过使用Boost.Asio计时器和async_wait()操作进行async_receive()操作来组成具有超时的异步读取操作。这种方法在Boost.Asio timeout examples中得到了证明，类似于：

// Start a timeout for the read.
boost::asio::deadline_timer timer(io_service);
timer.expires_from_now(boost::posix_time::seconds(1));
timer.async_wait(
  [&socket, &timer](const boost::system::error_code& error)
  {
    // On error, such as cancellation, return early.
    if (error) return;

    // Timer has expired, but the read operation's completion handler
    // may have already ran, setting expiration to be in the future.
    if (timer.expires_at() > boost::asio::deadline_timer::traits_type::now())
    {
      return;
    } 

    // The read operation's completion handler has not ran.
    boost::system::error_code ignored_ec;
    socket.close(ignored_ec);
  });

// Start the read operation.
socket.async_receive(buffer,
  [&socket, &timer](const boost::system::error_code& error,
    std::size_t bytes_transferred)
  {
    // Update timeout state to indicate the handler has ran.  This
    // will cancel any pending timeouts.
    timer.expires_at(boost::posix_time::pos_infin);

    // On error, such as cancellation, return early.
    if (error) return;

    // At this point, the read was successful and buffer is populated.
    // However, if the timeout occurred and its completion handler ran first,
    // then the socket is closed (!socket.is_open()).
  });

请注意，两个异步操作都可以在同一次迭代中完成，这使得两个完成处理程序都可以成功运行。因此，两个完成处理程序需要更新和检查状态的原因。有关如何管理州的更多详细信息，请参阅this答案。

使用std::future

Boost.Asio提供support for C++11 futures。当boost::asio::use_future作为异步操作的完成处理程序提供时，启动函数将返回一个std::future，该操作将在操作完成后完成。由于std::future支持定时等待，因此可以利用它来超时操作。请注意，由于调用线程将被阻塞等待将来，至少有一个其他线程必须处理io_service以允许async_receive()操作继续进行并履行承诺：

// Use an asynchronous operation so that it can be cancelled on timeout.
std::future<std::size_t> read_result = socket.async_receive(
   buffer, boost::asio::use_future);

// If timeout occurs, then cancel the read operation.
if (read_result.wait_for(std::chrono::seconds(1)) == 
    std::future_status::timeout)
{
  socket.cancel();
}
// Otherwise, the operation completed (with success or error).
else
{
  // If the operation failed, then read_result.get() will throw a
  // boost::system::system_error.
  auto bytes_transferred = read_result.get();
  // process buffer
}

为什么SO_RCVTIMEO不起作用

系统行为

SO_RCVTIMEO文档指出该选项仅影响执行套接字I / O的系统调用，例如read()和recvmsg()。它不会影响事件多路分解器，例如select()和poll()，它们仅监视文件描述符以确定I / O何时可以无阻塞地发生。此外，当发生超时时，I / O调用无法返回-1并将errno设置为EAGAIN或EWOULDBLOCK。

  

指定接收或发送超时，直到报告错误为止。 [...]如果没有传输数据并且已达到超时，则返回-1，并将错误号设置为EAGAIN或EWOULDBLOCK [...]超时仅对...有效执行套接字I / O的系统调用（例如read()，recvmsg()，[...];超时对select()，poll()，{{1}无效等等。

当基础文件描述符设置为非阻塞时，如果资源不能立即可用，则执行套接字I / O的系统调用将立即返回epoll_wait()或EAGAIN。对于非阻塞套接字，EWOULDBLOCK不会产生任何影响，因为调用将立即返回成功或失败。因此，对于SO_RCVTIMEO影响系统I / O调用，套接字必须阻塞。

Boost.Asio行为

首先，Boost.Asio中的异步I / O操作将使用事件多路分解器，例如SO_RCVTIMEO或select()。因此，poll()不会影响异步操作。

接下来，Boost.Asio的套接字具有两种非阻塞模式的概念（两者都默认为false）：

  • native_non_blocking()模式，大致对应于文件描述符的非阻塞状态。此模式会影响系统I / O调用。例如，如果有人调用SO_RCVTIMEO，那么socket.native_non_blocking(true)可能会失败，recv(socket.native_handle(), ...)设置为errno或EAGAIN。无论何时在套接字上启动异步操作，Boost.Asio都将启用此模式。
  • non_blocking()模式影响Boost.Asio的同步套接字操作。设置为EWOULDBLOCK时，Boost.Asio会将基础文件描述符设置为非阻塞，并且同步Boost.Asio套接字操作可能会因true（或等效系统错误）而失败。设置为boost::asio::error::would_block时，即使基础文件描述符是非阻塞的，Boost.Asio也会通过轮询文件描述符并重新尝试false或{{1返回。

EAGAIN的行为会阻止EWOULDBLOCK产生所需的行为。假设调用non_blocking()并且数据既不可用也不接收：

  • 如果SO_RCVTIMEO为false，则系统I / O调用将按socket.receive()超时。但是，Boost.Asio将立即阻止对文件描述符的轮询，使其可读，而不受non_blocking()的影响。最终结果是调用者在SO_RCVTIMEO中被阻止，直到收到数据或失败，例如远程对等关闭连接。
  • 如果SO_RCVTIMEO为真，则基础文件描述符也是非阻塞的。因此，系统I / O调用将忽略socket.receive()，立即返回non_blocking()或SO_RCVTIMEO，导致EAGAIN失败并显示EWOULDBLOCK。

理想情况下，要使socket.receive()与Boost.Asio一起使用，需要将boost::asio::error::would_block设置为false以使SO_RCVTIMEO生效，同时将native_non_blocking()设置为true防止对描述符进行轮询。但是，Boost.Asio不会support this：

  

SO_RCVTIMEO

     

如果模式为non_blocking()，但socket::native_non_blocking(bool mode)的当前值为false，则此功能会失败并显示non_blocking()，因为该组合没有意义。

答案 1 :(得分：0)

由于您正在接收数据，因此您可能需要设置：SO_RCVTIMEO而不是SO_SNDTIMEO

尽管混合增强和系统调用可能无法产生预期的结果。

供参考：

  

<强> SO_RCVTIMEO

     

设置超时值，该值指定输入函数在完成之前等待的最长时间。它接受时间   结构，以秒和微秒为单位指定   限制等待输入操作完成的时间。如果一个   接收操作在没有收到的情况下已经被阻止了这么多   附加数据，它将返回部分计数或错误设置为   如果没有收到数据，则[EAGAIN]或[EWOULDBLOCK]。默认为此   option为零，表示接收操作不会   超时。此选项采用timeval结构。请注意，并非所有   实现允许设置此选项。

但是这个选项只对读取操作产生影响，而不影响可能在异步实现中等待套接字的其他低级别函数（例如select和epoll），并且它似乎也不会影响异步asio操作。 / p>

我发现了一个可能适用于您的案例here的示例代码。

一个简化的例子（用c ++ 11编译）：

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <iostream>

void myclose(boost::asio::ip::tcp::socket& ps) { ps.close(); }

int main()
{
  boost::asio::io_service io;
  boost::asio::ip::tcp::acceptor::reuse_address option(true);
  boost::asio::ip::tcp::acceptor accept(io);
  boost::asio::ip::tcp::resolver resolver(io);
  boost::asio::ip::tcp::resolver::query query("0.0.0.0", "8080");
  boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
  accept.open(endpoint.protocol());
  accept.set_option(option);
  accept.bind(endpoint);
  accept.listen(30);
  boost::asio::ip::tcp::socket ps(io);
  accept.accept(ps);
  char buf[1024];
  boost::asio::deadline_timer timer(io, boost::posix_time::seconds(1));
  timer.async_wait(boost::bind(myclose, boost::ref(ps))); 
  ps.async_receive(boost::asio::buffer(buf, 1024),
           [](const boost::system::error_code& error,
              std::size_t bytes_transferred )
           {
             std::cout << bytes_transferred << std::endl;
           });
  io.run();
  return 0;
}
相关问题
最新问题