3

我在 C 中模拟 Windows 上的 TCP 通信。我有发送者和接收者通信。

发送方将特定大小的数据包发送给接收方。接收方获取它们并将接收到的每个数据包的 ACK 发送回发送方。如果发送方没有收到特定的数据包（它们在数据包内的标头中编号），它会再次将数据包发送给接收方。这是接收方的 getPacket 函数：

//get the next packet from the socket. set the packetSize to -1
//if it's the first packet.
//return: total bytes read
// return: 0 if socket has shutdown on sender side, -1 error, else number of bytes received
int getPakcet(char* chunkBuff, int packetSize, SOCKET AcceptSocket)
{
    int totalChunkLen = 0;
    int bytesRecv = -1;
    bool firstTime = false;

    if(packetSize == -1)
    {
        packetSize = MAX_PACKET_LENGTH;
        firstTime = true;
    }

    int needToGet = packetSize;

    do
    {
        char* recvBuff;
        recvBuff = (char*)calloc(needToGet, sizeof(char));

        if(recvBuff == NULL)
        {
            fprintf(stderr, "Memory allocation problem\n");
            return -1;
        }

        bytesRecv = recv(AcceptSocket, recvBuff, needToGet, 0);

        if(bytesRecv == SOCKET_ERROR)
        {
            fprintf(stderr, "recv() error %ld.\n", WSAGetLastError());
            totalChunkLen = -1;
            return -1;
        }

        if(bytesRecv == 0)
        {
            fprintf(stderr, "recv(): socket has shutdown on sender side");
            return 0;
        }
        else if(bytesRecv > 0)
        {
            memcpy(chunkBuff + totalChunkLen, recvBuff, bytesRecv);
            totalChunkLen += bytesRecv;
        }

        needToGet -= bytesRecv;
    }
    while((totalChunkLen < packetSize) && (!firstTime));

    return totalChunkLen;
}

我使用firstTime是因为第一次接收方不知道发送方要发送给它的正常包大小，所以我使用 aMAX_PACKET_LENGTH来获取一个包，然后将正常包大小设置为我收到的字节数.

我的问题是最后一个包裹。它的尺寸小于包装尺寸。所以让我们说最后一个包大小是2，正常包大小是4。所以recv()得到两个字节，继续while条件，然后totalChunkLen < packetSize 因为2<4它再次迭代循环并且卡住了，recv()因为它阻塞了，因为发送者没有什么可以发送.

在发送方我无法关闭连接，因为我没有收到 ACK，所以这是一种死锁。接收方卡住了，因为它正在等待更多的包裹，但发送方没有任何东西要发送。

我不想使用超时recv()或在包头中插入一个特殊字符来标记它是最后一个。

我能做些什么？

4

4 回答 4

2

使用低级套接字编程要牢记的概念是，您正在交换一堆字节，而没有传输强加的结构。您可以实现一个协议来描述消息，或者通过将您认为是“消息”的总长度放在开头，通过使用您在接收到的缓冲区中检查的定界符字节或序列，或者通过关闭最后的连接（后者看起来最简单，但不是最好的解决方案，因为您将希望在现实世界的程序中重用连接，因为设置它很昂贵）。

如果这看起来很复杂（实际上并不总是那么容易），您需要寻找一个为您封装这项工作的库，例如允许您发送和接收将由库序列化、描述和反序列化的对象代码。但是这项工作需要完成，它不会是传输层为你做的。

关于所示代码的一个小评论：您使用多个接收缓冲区分配创建内存泄漏......

于 2011-03-06T16:50:09.333 回答
2

您正在使用 TCP 在接收器和发送器之间进行通信，而 TCP 是面向流的协议。也就是说，您将字节流放在一端，然后将流从另一端取出，有序且没有损失。不能保证每个 send() 都会匹配另一端的 recv()，因为数据可能由于各种原因被分解。

因此，如果您使用 TCP 连接执行以下操作：

char buffer[] = "1234567890";
send(socket, buffer, 10, 0);

然后在接收器上：

char buffer[10];
int bytes = recv(socket, buffer, 10, 0);

当 recv() 返回时，字节可以是 0 到 10 之间的任意值。

TCP 在 IP 上运行，这是一种面向数据报的协议。这就是为什么 TCP 实现可以假设当它发送一个数据报时，它将在另一端接收整个数据报（或者可能不接收，或者无序接收）。如果你想模拟你至少有两个选择：

  1. 为您的 TCP 消息添加帧，以便您可以从中提取数据包。这涉及将诸如数据包大小之类的内容添加到您发送到流中的标头中。用它来模拟 TCP 是没有意义的，因为你的所有数据包总是会到达，总是按顺序到达，并且已经使用了底层的 TCP 流控制/拥塞避免机制。
  2. 使用数据报协议，例如 UDP。这将更接近 TCP 运行的 IP 层。

您可能应该使用选项 2，但如果您想通过 TCP 进行成帧路由，您可以例如（粗略的快速代码如下）：

// We do this to communicate with machines having different byte ordering
u_long packet_size = htonl(10); // 10 bytes packet
send(socket, &packet_size, 4, 0); // First send the frame size
send(socket, buffer, 10, 0); // Then the frame

接收端：

u_long packet_size; // Hold the size of received packet
int bytes_to_read = 4; // We send 4 bytes on the wire for size and expect 4
int nresult; // hold result of recv()
char *psize = &packet_size; // Point to first byte of size
while( bytes_to_read ) // Keep reading until we have all the bytes for the size
{
  nresult = recv(socket, psize, bytes_to_read, 0);
  if(nresult==0) deal with connection closed.
  bytes_to_read -= nresult;
  psize += nresult;
}
packet_size = ntohl(packet_size);
// Now we know the packet size we can proceed and read it similar to above
于 2011-03-06T20:09:55.903 回答
1

您可以在开始时指定每个数据包中的数据量（例如，前 2 个字节可以指定数据包大小），或者填充最后一个数据包，使其与其他数据包大小相同。

编辑：如果你真的想“模拟”TCP，那么你可能应该使用 recvfrom() 和 sendto()，然后你会收到不同大小的整个数据包的数据，你就不会有这个问题。

于 2011-03-06T16:06:21.383 回答
1

发件人需要告诉您的收件人它已经完成。这可以通过首先发送接收者可以预期的数据大小、始终发送相同数量的数据或发送一个标记值来指示后续不会有更多字节来完成。发送者也可以在完成发送时关闭连接，在这种情况下，当没有任何内容可读取并且检测到连接已关闭时，recv 将返回 0。

于 2011-03-06T16:13:14.843 回答