Node.js与C语言TCP通信中的数据流处理与消息帧定

// Node.js 服务器端示例
const net = require('net');

const server = net.createServer((socket) => {
    console.log('Client connected.');

    socket.on('data', (data) => {
        // 假设客户端也发送了带长度前缀的数据
        console.log('Received from client:', data.toString());
    });

    socket.on('end', () => {
        console.log('Client disconnected.');
    });

    socket.on('error', (err) => {
        console.error('Socket error:', err);
    });

    // 示例：发送一个消息
    function sendMessage(message) {
        const messageBuffer = Buffer.from(message, 'utf8');
        const messageLength = messageBuffer.length;

        // 创建一个4字节的Buffer来存储长度
        const lengthBuffer = Buffer.alloc(4);
        lengthBuffer.writeUInt32BE(messageLength, 0); // 使用大端字节序写入长度

        // 将长度Buffer和消息Buffer拼接起来发送
        socket.write(Buffer.concat([lengthBuffer, messageBuffer]));
        console.log(`Sent message: "${message}" (length: ${messageLength})`);
    }

    // 模拟发送多条消息
    setTimeout(() => sendMessage("Hello from Node.js server!"), 1000);
    setTimeout(() => sendMessage("This is a second message."), 2000);
    setTimeout(() => sendMessage("Longer message to test buffer handling on client side. This message is intentionally made longer to demonstrate how the client should handle larger data chunks correctly."), 3000);
});

const PORT = 3000;
server.listen(PORT, () => {
    console.log(`Server listening on port ${PORT}`);
});

// C 语言客户端示例 (GetData 函数改进)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define LENGTH_PREFIX_SIZE 4 // 长度前缀的字节数 (例如：32位无符号整数)
#define INITIAL_BUFFER_SIZE 1024 // 初始缓冲区大小

// 辅助函数：从套接字精确读取指定字节数
ssize_t read_exact(int socket_fd, void *buffer, size_t length) {
    size_t total_read = 0;
    ssize_t bytes_read;

    while (total_read < length) {
        bytes_read = recv(socket_fd, (char *)buffer + total_read, length - total_read, 0);
        if (bytes_read <= 0) {
            // 连接关闭 (bytes_read == 0) 或错误 (bytes_read == -1)
            if (bytes_read == 0) {
                fprintf(stderr, "Connection closed by peer.\n");
            } else {
                perror("recv error");
            }
            return -1; // 返回错误或连接关闭信号
        }
        total_read += bytes_read;
    }
    return total_read;
}

char *GetData(int socket_fd) {
    uint32_t message_length_net; // 网络字节序的消息长度
    uint32_t message_length_host; // 主机字节序的消息长度

    // 1. 读取4字节的长度前缀
    if (read_exact(socket_fd, &message_length_net, LENGTH_PREFIX_SIZE) == -1) {
        return NULL; // 读取长度失败
    }

    // 将网络字节序转换为本机字节序
    message_length_host = ntohl(message_length_net);

    printf("Expected message length: %u bytes\n", message_length_host);

    if (message_length_host == 0) {
        // 如果消息长度为0，直接返回一个空字符串或处理空消息
        char *empty_buffer = (char *)malloc(1);
        if (empty_buffer == NULL) {
            perror("malloc failed for empty buffer");
            return NULL;
        }
        empty_buffer[0] = '\0';
        return empty_buffer;
    }

    // 2. 根据解析出的长度分配缓冲区并读取消息内容
    char *buffer = (char *)malloc(message_length_host + 1); // +1 for null terminator
    if (buffer == NULL) {
        perror("malloc failed for message buffer");
        return NULL;
    }

    if (read_exact(socket_fd, buffer, message_length_host) == -1) {
        free(buffer);
        return NULL; // 读取消息内容失败
    }

    buffer[message_length_host] = '\0'; // 添加字符串结束符

    return buffer;
}

// 客户端主函数示例
int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char *received_data;

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket creation error");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(3000); // 替换为你的服务器端口

    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) { // 替换为你的服务器IP
        perror("Invalid address/ Address not supported");
        return -1;
    }

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("Connection Failed");
        return -1;
    }

    printf("Connected to server.\n");

    // 循环接收多条消息
    for (int i = 0; i < 3; ++i) { // 假设接收3条消息
        received_data = GetData(sock);
        if (received_data != NULL) {
            printf("Received message %d: \"%s\"\n", i + 1, received_data);
            free(received_data); // 释放内存
        } else {
            fprintf(stderr, "Failed to receive message %d or connection closed.\n", i + 1);
            break; // 退出循环，通常意味着连接已关闭或发生错误
        }
    }

    close(sock);
    return 0;
}