Node.js与C语言网络通信：理解TCP流与消息边界处理

const net = require('net');

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

    // 监听客户端数据（如果客户端有发送数据）
    socket.on('data', (data) => {
        console.log(`Received from client: ${data.toString()}`);
    });

    // 发送一个带有长度前缀的消息
    const sendMessage = (messageString) => {
        const messageBuffer = Buffer.from(messageString, 'utf8');
        const lengthBuffer = Buffer.alloc(4); // 4字节表示长度

        // 将消息长度写入长度Buffer，使用大端字节序 (BE - Big Endian)
        // C客户端通常使用网络字节序，即大端字节序
        lengthBuffer.writeUInt32BE(messageBuffer.length, 0); 

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

    // 示例：发送多条消息
    sendMessage("Hello from Node.js server!");
    setTimeout(() => {
        sendMessage("This is another message.");
    }, 1000);
    setTimeout(() => {
        sendMessage("And a third one, longer than the others to demonstrate variable length.");
    }, 2000);

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

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

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h> // For ntohl (network to host long)
#include <sys/socket.h>

// 辅助函数：确保读取到指定数量的字节
// 返回值：实际读取的字节数，0表示连接关闭，-1表示错误
ssize_t read_n_bytes(int fd, void *buf, size_t n) {
    size_t total_read = 0;
    ssize_t bytes_read;
    while (total_read < n) {
        bytes_read = recv(fd, (char *)buf + total_read, n - total_read, 0);
        if (bytes_read <= 0) { // 0 for disconnect, -1 for error
            return bytes_read;
        }
        total_read += bytes_read;
    }
    return total_read;
}

// 接收一个完整的消息（带有长度前缀）
char *GetData(int socket_fd) {
    uint32_t message_length_net; // 用于存储网络字节序的消息长度

    // 1. 读取4字节的长度前缀
    ssize_t res = read_n_bytes(socket_fd, &message_length_net, sizeof(message_length_net));
    if (res <= 0) {
        // 连接关闭或发生错误
        if (res == 0) {
            printf("Server disconnected.\n");
        } else {
            perror("Failed to read message length");
        }
        return NULL;
    }

    // 将网络字节序转换为本机字节序
    uint32_t message_length = ntohl(message_length_net); 
    printf("Expected message length: %u bytes\n", message_length);

    if (message_length == 0) {
        // 收到一个空消息
        char *empty_buffer = (char *)malloc(1);
        if (empty_buffer) *empty_buffer = '\0';
        return empty_buffer;
    }

    // 2. 根据读取到的长度分配缓冲区
    char *buffer = (char *)malloc(message_length + 1); // +1 用于字符串的null终止符
    if (buffer == NULL) {
        perror("Failed to allocate buffer for message");
        return NULL;
    }

    // 3. 读取消息体
    res = read_n_bytes(socket_fd, buffer, message_length);
    if (res <= 0) {
        perror("Failed to read message body");
        free(buffer);
        return NULL;
    }
    buffer[message_length] = '\0'; // null终止字符串
    return buffer;
}

// 简单的客户端连接函数
int connect_to_server(const char *ip, int port) {
    int sock = 0;
    struct sockaddr_in serv_addr;

    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(port);

    if (inet_pton(AF_INET, ip, &serv_addr.sin_addr) <= 0) {
        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");
    return sock;
}

int main() {
    int client_socket = connect_to_server("127.0.0.1", 12345); // 连接到Node.js服务器
    if (client_socket < 0) {
        return 1;
    }

    char *received_data;
    // 循环接收消息，直到服务器关闭连接或发生错误
    while ((received_data = GetData(client_socket)) != NULL) {
        printf("Received message: \"%s\"\n", received_data);
        free(received_data); // 释放动态分配的内存
    }

    close(client_socket); // 关闭套接字
    printf("Client disconnected.\n");
    return 0;
}