c++ - window ，C++ : two connections on one server socket?

Question

我不知道这是一个普遍的网络问题还是仅仅是一个编程问题，所以我决定把它贴在这里。

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

服务器和客户端在同一台机器上运行，并配置为使用端口 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() 并立即激活多个连接到客户端的套接字。