我可以通过 TCP 发送大约 10,000 ~ 20,000 字节的数据吗？我正在将图像(60 x 60)从 Android 客户端传输到 linux 服务器。在安卓上似乎没问题。在服务器端，如果我尝试将图片数据发送回客户端，则它不起作用。在客户端，如果我解析然后我得到一些我不应该得到的奇怪数字。

通过TCP传输大数据有什么技术问题吗？我该如何解决？ 提前致谢..

char* PictureResponsePacket::toByte(){

    /*
     * HEADER
     *
     * Magic number (4)
     * Data length  (4)
     * Packet Id    (2)
     * Packet type  (2)
     * Device Id    (48)
     *
     */

    /*
     * BODY
     *
     * Nickname  (48)
     * deviceId  (4)
     * m_pictureSize
     */

    int offset = 0;

    int headerLength = sizeof(int) + sizeof(int) + sizeof(short) + sizeof(short) + 48;
    int bodyLength = 48 + 4 + m_pictureSize;
    int dataLength = headerLength + bodyLength;
    m_dataLength = dataLength;

    log("PictureResponsePacket::toByte(), data length %d \n", m_dataLength);

    char *sendBuffer = new char[dataLength];
    memset(sendBuffer, 0x00, dataLength);

    char *ptr = sendBuffer;

    /*
     * -------------
     * HEADER
     * -------------
     */
    /*
     * Magic number
     */
    memcpy(ptr + offset, m_magicNumberBuffer, sizeof(int));
    offset += sizeof(int);

    /*
     * Data length
     */


    memcpy(ptr + offset, &m_dataLength, sizeof(int));
    offset += sizeof(int);

    /*
     * Packet id
     */
    memcpy(ptr + offset, &m_packetId, sizeof(short));
    offset += sizeof(short);

    /*
     * Packet type
     */
    memcpy(ptr + offset, &m_packetType, sizeof(short));
    offset += sizeof(short);

    /*
     *Device Id
     */

    memcpy(ptr + offset, m_deviceId.c_str(), m_deviceId.size());
    offset += 48;

    /*
     * -------------
     * BODY
     * -------------
     */
    memcpy(ptr + offset, m_senderDeviceId.c_str(), m_senderDeviceId.size());
    offset += 48;

    memcpy(ptr + offset, &m_pictureSize, sizeof(int));
    offset += sizeof(int);

    memcpy(ptr + offset, m_pictureData, m_pictureSize);
    offset += m_pictureSize;


    return sendBuffer;


}

我以这种方式获取 char* 并像这样发送它

                char * sBuffer = reponsePacket->toByte();
                int remainLength = reponsePacket->getDataLength();
                int currentSentLength = 0;
                SocketClient *client = work->getClient();

                while(remainLength > 0){

                    if(remainLength >= MAX_LENGTH)
                        currentSentLength = send(client->getFd(), sBuffer, MAX_LENGTH, MSG_NOSIGNAL);
                    else
                        currentSentLength = send(client->getFd(), sBuffer, remainLength, MSG_NOSIGNAL);

                    if(currentSentLength == -1){
                        log("WorkHandler::workLoop, connection has been lost \n");
                        break;
                    }

                    sBuffer += currentSentLength;
                    remainLength -= currentSentLength;

最佳答案

您尝试做的事情很简单(20K 不是“大”)。到目前为止，发生这种情况的最常见原因是忽略了 send 和 recv 的返回码。您应该牢记以下几点:

• send(2) 不能总是将所有数据从用户空间复制到内核空间。检查返回值
• 数据不会同时到达，因此您必须recv几次才能获得所有数据

实际上，在许多系统上，您可能会发送大量数据(内核会 mock 您的 20K)，但您必须在循环中接收。这是一个深受 Stevens readn 启发的函数。使用它代替 recv

ssize_t
readn(int fd, void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nread;
    char *ptr;

    ptr = vptr;
    nleft = n;
    while (nleft > 0) {
        if ((nread = read(fd, ptr, nleft)) < 0) {
            if (errno == EINTR)
                /* Loop back and call read again. */
                nread = 0;
            else
                /* Some other error; can't handle. */
                return -1;
        } else if (nread == 0)
            /* EOF. */
            break;

        nleft -= nread;
        ptr += nread;
    }
    return n - nleft;
}

编辑

您似乎忘记了字节序(正如 Andrew Finnell 怀疑的那样)。对于每个整数，您应该在发送之前执行类似的操作(在 memcpy 之前):

m_dataLength = htonl(m_datalength);

接收时是这样的:

m_dataLength = ntohl(m_datalength);

关于c++ - 如何通过 TCP 发送 10,000 ~ 20,000 字节的数据？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7011165/