Windows，C++：一个服务器套接字上有两个连接？

Question

我不知道这是一般网络问题还是仅仅是编程问题，所以我决定在这里发布。

尝试制作一个聊天程序，我遇到了以下情况：
- 我启动服务器程序；服务器在端口 22001 上创建一个套接字；服务器等待连接（accept() 挂起）；
- 我启动客户端程序；客户端连接无误；客户端发送无误；
- 服务器接收消息；
那么：
- 我在同一个端口上启动另一个客户端（客户端程序的另一个实例，而不停止或断开第一个客户端）；
- 第二个客户端连接没有错误（？！），尽管服务器不再处于“接受（）挂起”状态；
- 第二个客户端发送消息时没有显示任何错误 (?!);
- 服务器没有收到来自第二个客户端的消息 (?!);
实验的最后一步：
- 我在服务器端断开套接字；在这一刻，两个（？！）客户端在发送时都显示错误。

服务器和客户端在同一台机器上运行，并配置为使用端口 22001 和机器的 ip（比如 192.168.123.123）。
我使用带有超时的阻塞套接字进行读写，我使用 select() 来使 accept() 超时。我使用 SO_REUSEADDR。我承认我并不完全了解 select() 的工作原理。
我知道 tcp/ip 根据设置在连接之间产生差异：服务器 ip、服务器端口、客户端 ip 客户端端口。在我的情况下，客户端端口应该不同，看起来它们是不同的。但是 52428 是什么端口（？！），为什么这三个端口都一样（见下面的日志）？ 远程端口通过getpeername()获取，本地端口通过getsockname()获取。
我认为可以在同一端口上的服务器上有多个连接，但不在同一个套接字上。我错了吗？
请注意，服务器断开连接后，客户端 1 显示错误 10053，但客户端 2 显示错误 10054。
那么这一切怎么可能呢？如何在服务器上防止同一套接字上的多个连接但允许同一端口上的多个连接？

程序的输出如下：

Server:
 1) Skt 0: SocketListen 116 created - Port 22001 IP 192.168.123.123.
 2) Skt 0: Wait for client connection/
 3) Skt 0: SocketAccept 120 created.
 4) Skt 0: Remote port is 52428 (SocketListen).
 5) Skt 0: Remote port is 52428 (SocketAccept).
 6) Skt 0: Local  port is 22001 (SocketListen).
 7) Skt 0: Local  port is 22001 (SocketAccept).
 8) Skt 0: Client connected.
 9) Skt 0: InUse.
10) Skt 0: << Src=Cli1= Dst=Cli2= Body=Text_A_0.
11) Skt 0: << Src=Cli1= Dst=Cli2= Body=Text_B_0.
12) Skt 0: closing...
13) Skt 0: Both sockets (Listen and Accept/Connect) droped.
14) Skt 0: closed.

Client 1:
 1) Socket 116 created.
 2) Socket connected - Port 22001 IP 192.168.123.123.
 3) Remote port is 52428.
 4) Local  port is 62193
 5) Sent  to  Cli2 CliString: =Text_A_0=.
 6) Sent  to  Cli2 CliString: =Text_B_0=.
 7) ERROR !!! Port 22001 cannot be reached. Error =10053.
 8) ERROR !!! setsockopt( recv_timeout ) failed.
 9) Socket closed.

Client 2:
 1) Socket 116 created.
 2) Socket connected - Port 22001 IP 192.168.123.123.
 3) Remote port is 52428.
 4) Local  port is 62194
 5) Sent  to  Cli1 CliString: =Text_C_0=.
 6) Sent  to  Cli1 CliString: =Text_D_0=.
 7) ERROR !!! Port 22001 cannot be reached. Error =10054.
 8) ERROR !!! setsockopt( recv_timeout ) failed.
 9) Socket closed.

服务器，部分代码：

class SktSvr
{
    uint32 u32SktIdx;
    uint16 u16PortNr;
    string strIpAddr;
    WSADATA wsaData;
    struct sockaddr_in sAddr_Svr;
    SOCKET SktListen, SktAccept;
    int iRes;
    thread * pThreadRecv, * pThreadSend;
    mutex Mutex_CliId;
    static mutex Mutex_MailBoxes;
    static map< string, map< string, string > > MailBoxes; // key = destin , key = source, message
public:
    char achCliId[ MSG_SRC_STR_LEN + 1 ];
    bool bIsPrep;
    atomic<bool> bInUse;
    SktSvr( uint32 u32SktIdx_p, uint16 u16PortNr_p, char * pchAddr_p = "127.0.0.1" )
    {
        u16PortNr = u16PortNr_p;
        strIpAddr = pchAddr_p;
        u32SktIdx = u32SktIdx_p;
        bIsPrep = bInUse = false;
        pThreadRecv = pThreadSend = NULL;
        achCliId[ 0 ] = '\0';
        memset( &sAddr_Svr, 0, sizeof( sAddr_Svr ) );
        sAddr_Svr.sin_family = AF_INET; // server byte order
        wstring wstrIpAddr( strIpAddr.begin(), strIpAddr.end() );
        InetPton( AF_INET, wstrIpAddr.c_str(), &sAddr_Svr.sin_addr.s_addr ); //INADDR_ANY; // host addr
        sAddr_Svr.sin_port = htons( u16PortNr );
        char chOptVal = 1;
        if( ( iRes = WSAStartup( MAKEWORD( 2, 2 ), &wsaData ) ) != NO_ERROR )
        {
            printf( "\nSkt %d: ERROR !!! WSAStartup failed: %d.", u32SktIdx, iRes );
        }
        else if( ( SktListen = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) == INVALID_SOCKET ) // default protocol
        {
            printf( "\nSkt %d: ERROR !!! Port %d can not be opened.", u32SktIdx, u16PortNr );
            printf( "\nSkt %d: Error =%ld.", u32SktIdx, WSAGetLastError() );
            WSACleanup();
        }
        else if( setsockopt( SktListen, SOL_SOCKET, SO_REUSEADDR, &chOptVal, sizeof( chOptVal ) ) == -1 )
        {
            printf( "\nSkt %d: ERROR !!! Port %d set options failed.", u32SktIdx, u16PortNr );
            printf( "\nSkt %d: Error =%ld.", u32SktIdx, WSAGetLastError() );
            WSACleanup();
        }
        else if( bind( SktListen, ( struct sockaddr * ) &sAddr_Svr, sizeof( sAddr_Svr ) ) == SOCKET_ERROR )
        {
            printf( "\nSkt %d: ERROR !!! Port %d can not be bound.", u32SktIdx, u16PortNr );
            printf( "\nSkt %d: Error =%ld.", u32SktIdx, WSAGetLastError() );
            WSACleanup();
        }
        else if( listen( SktListen, 5 ) == SOCKET_ERROR ) // size for backlog queue = 5
        {
            printf( "\nSkt %d: ERROR !!! Port %d can not listen.", u32SktIdx, u16PortNr );
            printf( "\nSkt %d: Error =%ld.", u32SktIdx, WSAGetLastError() );
            WSACleanup();
        }
        else
        {
            printf( "\nSkt %d: SocketListen %d created - Port %d IP %s.",
                u32SktIdx, SktListen, u16PortNr, strIpAddr.c_str() );
            bIsPrep = true;
        }
    }
    bool SktConn()
    {
        int iRes;
        struct timeval tmvl;
        fd_set rfds;
        FD_ZERO( &rfds );
        FD_SET( SktListen, &rfds );
        tmvl.tv_sec = TIMEOUT_SKT_CONN_S;
        tmvl.tv_usec = 0;
        if( 0 ) {}
        else if( 1 && ( iRes = select( SktListen + 1, &rfds, (fd_set*)0, (fd_set*)0, &tmvl ) ) <= 0 )
        {
            // connect timeout
            //printf( "\nSkt %d: Socket Connect timeout.", u32SktIdx );
            bInUse = false;
        }
        else if( ! FD_ISSET( SktListen, &rfds ) )
        {
            printf( "\nSkt %d: Selected another.", u32SktIdx );
        }
        else if( ( SktAccept = accept( SktListen, NULL, NULL ) ) == INVALID_SOCKET )
        {    printf( "\nSkt %d: ERROR !!! Port %d did not connect.", u32SktIdx, u16PortNr );
            printf( "\nSkt %d: Error =%ld.", u32SktIdx, WSAGetLastError() );
            bInUse = false;
        }
        else
        {
            printf( "\nSkt %d: SocketAccept %d created.", u32SktIdx, SktAccept );
            struct sockaddr_in sAddr;
            socklen_t len;
            getpeername( SktListen, ( struct sockaddr* )&sAddr, &len );
            printf( "\nSkt %d: Remote port is %d (SocketListen).", u32SktIdx, ntohs( sAddr.sin_port ) );
            getpeername( SktAccept, ( struct sockaddr* )&sAddr, &len );
            printf( "\nSkt %d: Remote port is %d (SocketAccept).", u32SktIdx, ntohs( sAddr.sin_port ) );
            int iAddrLen = sizeof( sAddr );
            if( getsockname( SktListen, ( struct sockaddr * )&sAddr, &iAddrLen ) == 0 &&
                sAddr.sin_family == AF_INET && iAddrLen == sizeof( sAddr ) )
                printf( "\nSkt %d: Local  port is %d (SocketListen).", u32SktIdx, ntohs( sAddr.sin_port ) );
            if( getsockname( SktAccept, ( struct sockaddr * )&sAddr, &iAddrLen ) == 0 &&
                sAddr.sin_family == AF_INET && iAddrLen == sizeof( sAddr ) )
                printf( "\nSkt %d: Local  port is %d (SocketAccept).", u32SktIdx, ntohs( sAddr.sin_port ) );
            bInUse = true;
        }
        return bInUse;
    }

Answer 1

单个侦听套接字用于在单个端口上接受任意数量的连接。对于每个连接，accept() 创建并返回一个新套接字，这就是“每个连接一个套接字”的用武之地。您从未听到第二个客户端发送的消息的原因是您只从连接的套接字recv()给第一个客户。

如果客户端连接时侦听套接字不在accept() 调用中，则传入连接将排队。这是标准套接字行为，您不仅会在 Windows 上看到它，还会在 BSD、Linux 等上看到它。

接受队列的大小是一个套接字选项。

如果您不希望出现排队行为，则必须在接受第一个连接后立即关闭侦听套接字。但几乎可以肯定你想要的是使用select()（或WSAEventSelect、poll等）来监视客户端套接字和监听套接字，当监听套接字显示活动时，再次调用accept()并拥有多个连接到客户端的套接字同时处于活动状态。