c++ - 服务器客户端通过原始数据错误发送接收结构 C++

Question

我正在通过 TCP/IP 为结构(在我的例子中是“框架”)执行发送和接收功能。但是这些功能似乎没有解决，我找不到我的错误所在。我被要求将所有数据存储在一个 char 数组中并发送，同时接收 char 数组并将它们转换为结构。

struct frame {
int length;
int * body;
int tail;
};


void winsock_client::send_frame(frame f) {
    char * arr;
    char * tx;
    int length = 8 + f.length * sizeof(int);
    arr = new char[length];

    tx = (char*)&f.length; 
    for (int i = 0; i < sizeof(int); i++) {
        arr[i] = *(tx++);
    }

    for (int i = 0; i < f.length; i++) {
        tx =(char*)&f.body[i];

        for (int j = 0; j < sizeof(int); j++) {
            arr[4 + i * sizeof(int) + j] = *(tx++);
        }
    }

        tx = (char*)&f.tail;
    for (int i = 0; i < sizeof(int); i++) {
        arr[4 + f.length * sizeof(int) + i] = *(tx++);
    }

    send(client_socket, arr, sizeof(arr), 0);
}


void winsock_server::receive_frame(frame & f) {
int * rx;
recv(server_socket, rx_buffer, sizeof(rx_buffer), 0);
rx =(int *) &rx_buffer[0];
f.length = *rx;

f.body = new int[f.length];

rx = (int *)&rx_buffer[4];
for (int i = 0; i < f.length; i++) {
    f.body[i] = *(rx++);
}

rx = (int*)&rx_buffer[16];
f.tail = *rx;

}

谁能告诉我我的函数有什么错误？

Answer 1

您没有检查 send() 和 recv() 的返回值来确保您确实发送/接收了您期望的一切。 TCP 是一种流式传输，发送和接收之间没有 1:1 的关系，就像 UDP 中那样。这两个函数可以发送/接收比请求更少的字节，因此您需要处理它。

此外，您的 read_frame() 使用固定长度的缓冲区来接收数据，但您没有考虑实际发送了多少数据，因此您的缓冲区可能无法接收到全帧，或者更糟的是，可能会收到一个比它可以容纳的更大的帧。

代码也很难读。应该重写。

尝试更像这样的东西:

bool sendAll(SOCKET s, const void *buf, int len)
{
    const char *pbuf = (const char*) buf;
    while (len > 0)
    {
        int sent = send(s, pbuf, len, 0);
        if (sent == SOCKET_ERROR)
            return false;
        pbuf += sent;
        len -= sent;
    }
    return true;
}

bool winsock_client::send_frame(const frame &f)
{
    int size = (2 + f.length) * sizeof(u_long);

    char *arr = new char[size];

    // multi-byte integers should always be transmitted in network
    // byte order to avoid any endian issues across machine boundaries...

    u_long *ptr = (u_long*) arr;

    *ptr++ = htonl(f.length);

    for (int i = 0; i < f.length; ++i)
        *ptr++ = htonl(f.body[i]);

    *ptr = htonl(f.tail);

    bool result = sendAll(client_socket, arr, size);

    delete[] arr;

    return result;
}

bool recvAll(SOCKET s, void *buf, int len)
{
    char *pbuf = (char*) buf;
    while (len > 0)
    {
        int recvd = recv(s, pbuf, len, 0);
        if (recvd <= 0) // -1 on error, 0 on disconnect
            return false;
        pbuf += recvd;
        len -= recvd;
    }
    return true;
}

bool winsock_server::receive_frame(frame &f)
{
    u_long temp;

    if (!recvAll(server_socket, &temp, sizeof(temp)))
        return false;
    f.length = ntohl(temp);

    u_long *arr = new u_long[f.length+1];

    if (!recvAll(server_socket, arr, sizeof(u_long) * (f.length + 1)))
    {
        delete[] arr;
        return false;
    }

    f.body = new int[f.length];

    for(int i = 0; i < f.length; ++i)
        f.body[i] = ntohl(arr[i]);

    f.tail = ntohl(arr[f.length]);

    delete[] arr;

    return true;
}

或者，如果您考虑到套接字已经为您做了自己的内部缓冲，您可以稍微简化代码:

bool sendAll(SOCKET s, const void *buf, int len)
{
    const char *pbuf = (const char*) buf;
    while (len > 0)
    {
        int sent = send(s, pbuf, len, 0);
        if (sent == SOCKET_ERROR)
            return false;
        pbuf += sent;
        len -= sent;
    }
    return true;
}

bool sendInt(SOCKET s, int value)
{
    // multi-byte integers should always be transmitted in network
    // byte order to avoid any endian issues across machine boundaries...
    u_long temp = htonl(value);
    return sendAll(s, &temp, sizeof(temp));
}

bool winsock_client::send_frame(const frame &f)
{
    if (!sendInt(client_socket, f.length))
        return false;

    for (int i = 0; i < f.length; ++i)
    {
        if (!sendInt(client_socket, f.body[i]))
            return false;
    }

    return sendInt(client_socket, f.tail);
}

bool recvAll(SOCKET s, void *buf, int len)
{
    char *pbuf = (char*) buf;
    while (len > 0)
    {
        int recvd = recv(s, pbuf, len, 0);
        if (recvd <= 0) // -1 on error, 0 on disconnect
            return false;
        pbuf += recvd;
        len -= recvd;
    }
    return true;
}

bool recvInt(SOCKET s, int &value)
{
    u_long temp;
    bool result = recvAll(s, &temp, sizeof(temp));
    if (result) value = ntohl(temp);
    return result;
}

bool winsock_server::receive_frame(frame &f)
{
    if (!recvInt(server_socket, f.length))
        return false;

    f.body = new int[f.length];

    for(int i = 0; i < f.length; ++i)
    {
        if (!recvInt(server_socket, f.body[i]))
        {
            delete[] f.body;
            return false;
        }
    }

    if (!recvInt(server_socket, f.tail))
    {
        delete[] f.body;
        return false;
    }

    return true;
}