通过c/c++中的tcp套接字发送数据时，数据被切断

Question

当我通过 TCP 套接字发送长消息时，它们会被切断。根据目的地的不同而不同。当在我的机器上本地发送和接收时，一切都会完成。当在我的服务器上本地发送和接收时，它会在第 21846 个字节后一致被切断。当从我的机器发送到服务器时，它始终在第 1441 个字节处被切断。服务器在斯德哥尔摩，我在英国。当客户端位于 Windows 上并使用 Windows 的网络代码时，也会出现同样的问题。

这里客户端应该发送 29 999 个零和一个空终止符，接收它们并打印它们。当我用 wc 计算它们时，我得到了我收到的实际字节数。因此，这些数字代表了双向传输，但从测试来看，我可以说该问题具有相同的单向属性。

据我所知，读/写函数是阻塞的，所以问题不在于函数退出之前数据尚未完全到达 - 这是手册页中描述的问题。

我怎样才能解决这个问题？

到底部查看解决方案

这是我用来测试这个的代码：

服务器/main.cpp

#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>

#include "aes/aes.hpp"
#include "network.hpp"
#include <thread>

using namespace std;

int main()
{
    int server_socket = InitServerSocket(26969);
    std::cout << "Listening..." << std::endl;

    while (true) {
        // accept incoming connections - blocking
        int client_socket = accept(server_socket, NULL, NULL);

        if (client_socket < 0) {
            std::cerr << "Unable to accept";
            close(server_socket);
            return 1;
        }

        char long_text[30000];
        read(client_socket, long_text, 30000);

        std::cout << long_text << std::endl;

        write(client_socket, long_text, 30000);

        close(client_socket);
    }

    return 0;
}

初始化服务器套接字（）：

int InitServerSocket(int port)
{
    struct sockaddr_in server_address;
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(port);
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);

    int server_socket;
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0) {
        perror("Unable to create socket");
        _exit(1);
    }

    int result = bind(
        server_socket,
        (struct sockaddr*)&server_address,
        sizeof(server_address));
    if (result < 0) {
        perror("Unable to bind");
        _exit(1);
    }

    if (listen(server_socket, 1000) < 0) {
        perror("Unable to listen");
        _exit(1);
    }

    return server_socket;
}

客户端/main.cpp

#include <arpa/inet.h>
#include <iostream>
#include <netdb.h>
#include <string.h>
#include <string>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include "network.hpp"

using namespace std;

int main()
{
    int socket = ConnectToHost("70.34.195.74", 26969);

    char long_text[30000];
    for (int i = 0; i < 30000; i++)
        long_text[i] = '0';
    long_text[29999] = '\0';

    write(socket, long_text, 30000);

    read(socket, long_text, 30000);

    std::cout << long_text << std::endl;

    CloseConnection(socket);

    return 0;
}

连接到主机（）：

int ConnectToHost(char* IPAddress, int PortNo)
{
    // create a socket
    int network_socket; // socket descriptor ~= pointer ~= fd
    network_socket = socket(AF_INET, SOCK_STREAM, 0);
    // specify a destination address
    struct sockaddr_in server_address;
    server_address.sin_family = AF_INET; // specify protocol
    server_address.sin_port = htons(PortNo); // specify port
    // server_address.sin_addr.s_addr = a.s_addr; // specify resolved ip
    server_address.sin_addr.s_addr = inet_addr(IPAddress);

    // connect
    int connection_status = connect(
        network_socket,
        (struct sockaddr*)&server_address,
        sizeof(server_address));
    if (connection_status == -1)
        std::cout << "Failed to conect to remote host\n";
    return network_socket;
}

解决方案：

以下是我为解决该问题而编写的包装函数：

int Send(int soc, char* buffer, int size)
{
    int ret = -1;
    int index = 0;

    do {
        ret = write(soc, buffer + index, size - index);
        index += ret;
    } while (ret > 0);

    if (ret == -1)
        return -1;
    else
        return 1;
};

int Recv(int soc, char* buffer, int size)
{
    int ret = -1;
    int index = 0;

    do {
        ret = read(soc, buffer + index, size - index);
        index += ret;
    } while (ret > 0);

    if (ret == -1)
        return -1;
    else
        return 1;
};

Answer 1

write(client_socket, long_text, 30000);

无论如何，您无法保证所有 30000 字节都会被写入，即使使用阻塞套接字也是如此。您必须检查 的write()返回值以确定实际写入了多少字节，然后实现所需的逻辑以重试，无论剩余的内容如何写入，并以这种方式继续，直到所有 30000 字节都写入套接字。这就是套接字始终工作的方式。

read(socket, long_text, 30000);

同样的事情，你必须检查返回值。如果套接字只有一百个字节的未读数据等待，您将获得这 100 个字节并read()返回 100。如果阻塞套接字没有任何未读数据，read()则将阻塞。如果套接字最终接收到 1 个字节的数据包，read()则返回 1，这表明仅读取了 1 个字节。

我怎样才能解决这个问题？

您必须始终检查 everyread()和write()返回的内容，并进行相应操作。如果您需要从套接字读取或写入更多数据，请重试，然后执行此操作。

所以问题不在于函数退出之前数据尚未完全到达 - 这是手册页中描述的问题。

手册页还描述了返回值的read()含义write()：负值表示错误，正值表示实际读取或写入了多少字节。只有读取和写入常规文件才能保证读取或写入请求的字节数（除非读取到达文件末尾）。