这个问题来自 Why is nonblocking socket writable before connect() or accept()? .

以下代码生成一个线程来监听 TCP 连接。主线程连接到服务器监听的地址。

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <pthread.h>
#include <semaphore.h>

class SafeSocket
{
public:

  /** Ctor.
   * Creates a nonblocking socket at the specified IP in the AF_INET family and
   * at a dynamic port.
   */
  SafeSocket( const std::string& ip )
  {
    in_addr_t host_ip = inet_network( ip.c_str() );
    if ( ( socket_ = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 )
    {
      std::cout << "socket() failed: " << errno << " " << strerror( errno )
                << std::endl;
      socket_ = -1;
    }
    sockaddr_in si;
    memset( &si, 0, sizeof( si ) );
    si.sin_family = AF_INET;
    si.sin_port = 0; // Dynamic port
    si.sin_addr.s_addr = htonl( host_ip );
    if ( bind( socket_, (sockaddr*)&si, sizeof si ) )
    {
      std::cout << "bind() failed: " << errno << " " << strerror( errno )
                << std::endl;
      close( socket_ );
      socket_ = -1;
    }
    // Make the socket do nonblocking connect().
    int flags = fcntl( socket_, F_GETFL, 0 );
    fcntl( socket_, F_SETFL, flags | O_NONBLOCK );
  }

  ~SafeSocket()
  {
    if ( socket_ >= 0 )
    {
      shutdown( socket_, SHUT_RDWR );
      close( socket_ );
    }
  }

  operator int() const
  {
    return socket_;
  }

private:

  int socket_;
};

int connectToClient( const SafeSocket& sock, const std::string& clientIp,
                     const int clientPort )
{
  struct sockaddr_in clientAddr;
  memset( &clientAddr, 0, sizeof clientAddr );
  inet_pton( AF_INET, clientIp.c_str(), &clientAddr.sin_addr );
  clientAddr.sin_family = AF_INET;
  clientAddr.sin_port = htons( clientPort );
  return connect( sock, (sockaddr*)&clientAddr, sizeof clientAddr );
}

std::string serverIp( "127.0.0.200" );
int serverPort = 9099; // Random, hopefully unused.
sem_t listenSem;

/** Entry point to pthread.
 */
void* acceptConnection( void* arg )
{
  int listenSock = socket( PF_INET, SOCK_STREAM, 0 );
  if ( listenSock < 0 )
  {
    std::cout << "socket() failed: " << errno << " " << strerror( errno )
              << std::endl;
    return NULL;
  }

  sockaddr_in si;
  si.sin_family = AF_INET;
  inet_aton( serverIp.c_str(), &si.sin_addr );
  si.sin_port = htons( serverPort );

  int optval = 1;
  setsockopt( listenSock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval);

  int result = bind( listenSock, (sockaddr*)&si, sizeof si );
  if ( result )
  {
    std::cout << "bind() failed: " << errno << " " << strerror( errno )
              << std::endl;
    close( listenSock );
    return NULL;
  }

  std::cout << "listening on socket " << listenSock << std::endl;
  if ( listen( listenSock, 3 ) )
  {
    std::cout << "listen() failed: " << errno << " " << strerror( errno )
              << std::endl;
    close( listenSock );
    return NULL;
  }

  sem_post( &listenSem );

  fd_set readfds;
  FD_ZERO( &readfds );
  FD_SET( listenSock, &readfds );
  struct timeval ts = { 5, 0 };
  if ( -1 != select( listenSock + 1, &readfds, NULL, NULL, &ts ) )
  {
    if ( FD_ISSET( listenSock, &readfds ) )
    {
      sockaddr_in peerSi;
      socklen_t peerAddrLen = sizeof peerSi;
      memset( &peerSi, 0, peerAddrLen );
      sleep( 3 );
      int acceptSock = accept( listenSock, (sockaddr*)&peerSi, &peerAddrLen );
      if ( acceptSock > 0 )
      {
        std::cout << "accepted connection on socket " << acceptSock
                  << std::endl;
        close( acceptSock );
      }
    }
    else
    {
      std::cout << "did not receive a connection to accept." << std::endl;
    }
  }
  close( listenSock );
  return NULL;
}

int main( int argc, char* argv[] )
{
  sem_init( &listenSem, 0, 0 );

  SafeSocket s( "127.0.0.100" );
  std::cout << "Created socket " << s << std::endl;

  pthread_t tid;
  pthread_create( &tid, NULL, acceptConnection, NULL );

  timespec listenTimeout;
  clock_gettime( CLOCK_REALTIME, &listenTimeout );
  listenTimeout.tv_sec += 5;
  sem_timedwait( &listenSem, &listenTimeout );

  fd_set readFds;
  fd_set writeFds;

  FD_ZERO( &readFds );
  FD_ZERO( &writeFds );

  FD_SET( s, &writeFds );

  timeval timeout = { 5, 0 };
  int result = connectToClient( s, serverIp, serverPort );
  std::cout << "connectToClient() returned " << result << " "
            << errno << " " << strerror( errno ) << std::endl;

  if ( -1 == select( s+1, &readFds, &writeFds, NULL, &timeout ) )
  {
    std::cout << "select() failed: " << errno << " " << strerror( errno )
              << std::endl;
  }

  if ( FD_ISSET( s, &writeFds ) )
  {
    std::cout << s << " is writable!" << std::endl;
    int result = -1;
    socklen_t result_len = sizeof result;
    getsockopt( s, SOL_SOCKET, SO_ERROR, &result, &result_len );
    std::cout << "result: " << result << " " << strerror( result ) << std::endl;
  }

  pthread_join( tid, NULL );
  return 0;
}

输出:

>g++ --version
g++ (GCC) 4.8.3 20140911 (Red Hat 4.8.3-7)
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

>g++ -g main.cpp 
>
>./a.out 
Created socket 3                                             // Immediate
listening on socket 4                                        // Immediate
connectToClient() returned -1 115 Operation now in progress  // Immediate
3 is writable!                                               // Immediate
result: 0 Success                                            // Immediate
accepted connection on socket 5                              // Delayed

EJP，评论者at the noted question ，注意到在这种情况下，只要“目标 TCP 正在握手”，select() 就会阻塞。

那么，有没有办法延长这个“TCP 握手”过程？ IE。我想延长 select() 阻塞等待套接字 s 变为可写的时间。这可以做到吗？您可能会注意到我试图通过在接受之前添加一个 sleep() 来做到这一点，但这不起作用。

最佳答案

握手遵循以下阶段:

• 第 1 阶段:连接在客户端上运行。这从您调用 connect 开始运行，直到客户端至少从服务器获取 SYN+ACK 数据包。我说至少是因为客户端内核可能需要一段时间来处理该数据包。我的理解是，在第 1 阶段结束之前，套接字将不可写。

• 第 2 阶段:套接字在客户端可写；连接完成。服务器尚未从接受中返回。这包括服务器等待从客户端接收 ACK 的时间，以及接收该 ACK 和服务器应用程序调用 accept 之间的任何时间(加上等待调用 accept 得到处理)

• 第 3 阶段:双方完成。

我已经完成了这些阶段:我画出的区别旨在让讨论您的问题变得容易，而不是遵循 TCP 状态机的任何方面。

没有有效的方法来延长第 1 阶段，当然也没有办法让第 1 阶段包含第 2 阶段。您可以在客户端的内核中添加一些延迟，但这将是任意的并且与网络上发生的任何事情无关。

第 1 阶段和第 2 阶段之间的时间差异完全与服务器机器内的网络延迟和处理有关。没有客户可以采取行动的触发器。

对于许多应用程序来说，希望一旦套接字可写就开始写入。如果不是，普遍接受的解决方案是让您的协议(protocol)让服务器向客户端发送初始问候语。然后，等待套接字可读并在执行之前处理该问候语。

关于c++ - 我可以延长接受服务器的 TCP 握手持续时间吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47603936/