# TCP Socket编程实战：协议定制与网络计算器实现

在网络编程领域，基于TCP协议的Socket通信是实现可靠数据传输的基石。通过自定义应用层协议，可以在TCP连接上构建复杂的网络应用。本文以网络计算器为例，详细展示如何设计协议、实现客户端-服务器架构，并处理网络通信中的各种实际问题。

## TCP Socket基础与协议设计原则

TCP提供面向连接的可靠字节流传输，但应用层需要自定义协议来定义数据格式和交互逻辑。设计网络协议时需考虑以下关键要素：

```c

// 协议设计基础结构

#include <stdint.h>

// 协议版本定义

#define PROTOCOL_VERSION 1

#define MAX_DATA_SIZE 1024

// 操作类型枚举

typedef enum {

    OP_ADD = 0x01,      // 加法

    OP_SUB = 0x02,      // 减法

    OP_MUL = 0x03,      // 乘法

    OP_DIV = 0x04,      // 除法

    OP_POW = 0x05,      // 幂运算

    OP_SQRT = 0x06      // 平方根

} OperationType;

// 协议错误码

typedef enum {

    ERROR_NONE = 0x00,

    ERROR_INVALID_OPERATION = 0x01,

    ERROR_DIVISION_BY_ZERO = 0x02,

    ERROR_OVERFLOW = 0x03,

    ERROR_INVALID_NUMBER = 0x04,

    ERROR_PROTOCOL = 0xFF

} ErrorCode;

// 协议头部结构（固定大小）

typedef struct __attribute__((packed)) {

    uint8_t version;        // 协议版本

    uint8_t operation;      // 操作类型

    uint8_t error_code;     // 错误码（响应时使用）

    uint32_t seq_num;       // 序列号（用于请求-响应匹配）

    uint32_t data_len;      // 数据部分长度（字节）

} ProtocolHeader;

```

## 网络计算器协议详细设计

基于TCP的可靠传输，设计计算器专用协议：

```c

// calculator_protocol.h

#ifndef CALCULATOR_PROTOCOL_H

#define CALCULATOR_PROTOCOL_H

#include <stdint.h>

#include <stdbool.h>

// 协议常量定义

#define CALC_PROTOCOL_MAGIC 0x43414C43  // "CALC"的ASCII码

#define MAX_OPERANDS 10

#define MAX_ERROR_MSG 256

// 操作数数据结构

typedef struct {

    double values[MAX_OPERANDS];

    int count;

} Operands;

// 请求消息结构

typedef struct {

    ProtocolHeader header;

    Operands operands;

} RequestMessage;

// 响应消息结构

typedef struct {

    ProtocolHeader header;

    double result;

    char error_msg[MAX_ERROR_MSG];

} ResponseMessage;

// 协议序列化/反序列化函数声明

bool serialize_request(const RequestMessage* req, uint8_t* buffer, size_t* len);

bool deserialize_request(const uint8_t* buffer, size_t len, RequestMessage* req);

bool serialize_response(const ResponseMessage* resp, uint8_t* buffer, size_t* len);

bool deserialize_response(const uint8_t* buffer, size_t len, ResponseMessage* resp);

// 协议验证函数

bool validate_protocol_header(const ProtocolHeader* header);

bool validate_operation(uint8_t operation);

bool validate_operands(uint8_t operation, const Operands* operands);

#endif // CALCULATOR_PROTOCOL_H

```

## 协议实现与数据处理

实现协议的序列化和验证逻辑：

```c

// calculator_protocol.c

#include "calculator_protocol.h"

#include <string.h>

#include <math.h>

#include <arpa/inet.h>

// 序列化请求

bool serialize_request(const RequestMessage* req, uint8_t* buffer, size_t* len) {

    if (!req || !buffer || !len) return false;

    

    size_t offset = 0;

    

    // 复制头部（注意字节序转换）

    ProtocolHeader net_header = req->header;

    net_header.seq_num = htonl(req->header.seq_num);

    net_header.data_len = htonl(sizeof(double) * req->operands.count);

    

    memcpy(buffer + offset, &net_header, sizeof(ProtocolHeader));

    offset += sizeof(ProtocolHeader);

    

    // 复制操作数（转换为网络字节序）

    for (int i = 0; i < req->operands.count; i++) {

        uint64_t net_double;

        memcpy(&net_double, &req->operands.values[i], sizeof(double));

        // 注意：double类型在不同平台可能有不同表示，实际项目中需更严谨处理

        memcpy(buffer + offset, &net_double, sizeof(double));

        offset += sizeof(double);

    }

    

    *len = offset;

    return true;

}

// 反序列化请求

bool deserialize_request(const uint8_t* buffer, size_t len, RequestMessage* req) {

    if (!buffer || len < sizeof(ProtocolHeader) || !req) return false;

    

    size_t offset = 0;

    

    // 解析头部

    memcpy(&req->header, buffer + offset, sizeof(ProtocolHeader));

    req->header.seq_num = ntohl(req->header.seq_num);

    req->header.data_len = ntohl(req->header.data_len);

    

    offset += sizeof(ProtocolHeader);

    

    // 验证头部

    if (!validate_protocol_header(&req->header)) {

        return false;

    }

    

    // 计算操作数数量

    int operand_count = req->header.data_len / sizeof(double);

    if (operand_count > MAX_OPERANDS || operand_count < 1) {

        return false;

    }

    

    req->operands.count = operand_count;

    

    // 解析操作数

    for (int i = 0; i < operand_count; i++) {

        if (offset + sizeof(double) > len) {

            return false;

        }

        

        uint64_t net_double;

        memcpy(&net_double, buffer + offset, sizeof(double));

        memcpy(&req->operands.values[i], &net_double, sizeof(double));

        offset += sizeof(double);

    }

    

    return true;

}

// 协议验证

bool validate_protocol_header(const ProtocolHeader* header) {

    if (!header) return false;

    

    // 检查版本

    if (header->version != PROTOCOL_VERSION) {

        return false;

    }

    

    // 检查操作类型

    if (!validate_operation(header->operation)) {

        return false;

    }

    

    return true;

}

bool validate_operation(uint8_t operation) {

    return (operation >= OP_ADD && operation <= OP_SQRT);

}

bool validate_operands(uint8_t operation, const Operands* operands) {

    if (!operands || operands->count < 1) return false;

    

    switch (operation) {

        case OP_ADD:

        case OP_SUB:

        case OP_MUL:

            return operands->count >= 2;

        

        case OP_DIV:

            if (operands->count != 2) return false;

            // 检查除数不能为0

            return operands->values[1] != 0.0;

        

        case OP_POW:

            return operands->count == 2;

        

        case OP_SQRT:

            if (operands->count != 1) return false;

            // 检查平方根参数不能为负数

            return operands->values[0] >= 0.0;

        

        default:

            return false;

    }

}

```

## 服务器端完整实现

实现可处理多客户端的计算器服务器：

```c

// calculator_server.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <pthread.h>

#include <signal.h>

#include "calculator_protocol.h"

#define SERVER_PORT 8888

#define MAX_CLIENTS 100

#define BUFFER_SIZE 4096

// 全局变量

volatile sig_atomic_t server_running = 1;

// 信号处理函数

void signal_handler(int sig) {

    server_running = 0;

}

// 计算函数

double perform_calculation(uint8_t operation, const Operands* operands, char* error_msg) {

    double result = 0.0;

    error_msg[0] = '\0';

    

    switch (operation) {

        case OP_ADD:

            result = 0.0;

            for (int i = 0; i < operands->count; i++) {

                result += operands->values[i];

            }

            break;

        

        case OP_SUB:

            result = operands->values[0];

            for (int i = 1; i < operands->count; i++) {

                result -= operands->values[i];

            }

            break;

        

        case OP_MUL:

            result = 1.0;

            for (int i = 0; i < operands->count; i++) {

                result *= operands->values[i];

            }

            break;

        

        case OP_DIV:

            if (operands->values[1] == 0.0) {

                strcpy(error_msg, "除数不能为零");

                return 0.0;

            }

            result = operands->values[0] / operands->values[1];

            break;cf.ywaikang.com/xf.ywaikang.com/0i.ywaikang.com

        

        case OP_POW:

            result = pow(operands->values[0], operands->values[1]);

            break;

        

        case OP_SQRT:

            if (operands->values[0] < 0.0) {

                strcpy(error_msg, "平方根参数不能为负数");

                return 0.0;

            }

            result = sqrt(operands->values[0]);

            break;

        

        default:

            strcpy(error_msg, "未知操作类型");

            break;

    }

    

    // 检查溢出

    if (isinf(result)) {

        strcpy(error_msg, "计算结果溢出");

    } else if (isnan(result)) {

        strcpy(error_msg, "计算结果无效");

    }

    

    return result;

}

// 客户端连接处理线程

void* handle_client(void* arg) {

    int client_fd = *(int*)arg;

    free(arg);  // 释放传入的参数内存

    

    uint8_t buffer[BUFFER_SIZE];

    struct sockaddr_in client_addr;

    socklen_t addr_len = sizeof(client_addr);

    

    // 获取客户端地址

    getpeername(client_fd, (struct sockaddr*)&client_addr, &addr_len);

    char client_ip[INET_ADDRSTRLEN];

    inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));

    

    printf("[+] 客户端连接: %s:%d\n", client_ip, ntohs(client_addr.sin_port));

    

    while (server_running) {

        // 接收请求

        ssize_t bytes_received = recv(client_fd, buffer, sizeof(ProtocolHeader), MSG_WAITALL);

        

        if (bytes_received <= 0) {

            if (bytes_received == 0) {

                printf("[-] 客户端断开连接: %s:%d\n", client_ip, ntohs(client_addr.sin_port));

            } else {

                perror("recv错误");

            }

            break;

        }

        

        // 解析头部

        ProtocolHeader header;

        memcpy(&header, buffer, sizeof(ProtocolHeader));

        header.seq_num = ntohl(header.seq_num);

        header.data_len = ntohl(header.data_len);

        

        // 验证头部

        if (!validate_protocol_header(&header)) {

            printf("[!] 无效协议头部来自 %s\n", client_ip);

            break;

        }

        

        // 接收数据部分

        size_t data_len = header.data_len;

        if (data_len > 0) {

            if (data_len > BUFFER_SIZE - sizeof(ProtocolHeader)) {

                printf("[!] 数据过长来自 %s\n", client_ip);

                break;

            }

            

            bytes_received = recv(client_fd, buffer + sizeof(ProtocolHeader), data_len, MSG_WAITALL);

            if (bytes_received != data_len) {

                printf("[!] 数据接收不完整来自 %s\n", client_ip);

                break;

            }

        }

        

        // 解析完整请求

        RequestMessage request;

        if (!deserialize_request(buffer, sizeof(ProtocolHeader) + data_len, &request)) {

            printf("[!] 协议解析失败来自 %s\n", client_ip);

            break;

        }

        

        // 验证操作数

        char error_msg[MAX_ERROR_MSG] = {0};

        if (!validate_operands(header.operation, &request.operands)) {

            strcpy(error_msg, "无效的操作数");

            header.error_code = ERROR_INVALID_NUMBER;

        }

        

        // 执行计算

        double result = 0.0;

        if (error_msg[0] == '\0') {

            result = perform_calculation(header.operation, &request.operands, error_msg);

            

            if (error_msg[0] != '\0') {

                header.error_code = ERROR_INVALID_OPERATION;

            } else {

                header.error_code = ERROR_NONE;

            }

        }

        

        // 准备响应

        ResponseMessage response;

        response.header = header;

        response.result = result;

        strncpy(response.error_msg, error_msg, MAX_ERROR_MSG - 1);

        response.error_msg[MAX_ERROR_MSG - 1] = '\0';

        

        // 发送响应

        uint8_t resp_buffer[BUFFER_SIZE];

        size_t resp_len = 0;

        

        if (serialize_response(&response, resp_buffer, &resp_len)) {

            send(client_fd, resp_buffer, resp_len, 0);

            printf("[=] 处理请求: 操作=%d, 序列号=%u, 结果=%f\n", 

                   header.operation, header.seq_num, result);

        }

    }

    

    close(client_fd);

    pthread_exit(NULL);

}

int main() {

    int server_fd;

    struct sockaddr_in server_addr;

    

    // 设置信号处理

    signal(SIGINT, signal_handler);

    signal(SIGTERM, signal_handler);

    

    printf("=== TCP网络计算器服务器 ===\n");

    printf("端口: %d\n", SERVER_PORT);

    printf("按Ctrl+C停止服务器\n\n");

    

    // 创建socket

    server_fd = socket(AF_INET, SOCK_STREAM, 0);

    if (server_fd < 0) {

        perror("socket创建失败");

        exit(EXIT_FAILURE);

    }

    

    // 设置socket选项

    int opt = 1;

    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {

        perror("setsockopt失败");

        close(server_fd);

        exit(EXIT_FAILURE);

    }

    

    // 设置服务器地址

    memset(&server_addr, 0, sizeof(server_addr));

    server_addr.sin_family = AF_INET;

    server_addr.sin_addr.s_addr = INADDR_ANY;

    server_addr.sin_port = htons(SERVER_PORT);

    

    // 绑定地址

    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {

        perror("bind失败");

        close(server_fd);

        exit(EXIT_FAILURE);

    }

    

    // 开始监听

    if (listen(server_fd, MAX_CLIENTS) < 0) {

        perror("listen失败");

        close(server_fd);

        exit(EXIT_FAILURE);

    }

    

    printf("服务器启动成功，等待连接...\n");

    

    // 主循环

    while (server_running) {

        struct sockaddr_in client_addr;

        socklen_t client_len = sizeof(client_addr);

        

        // 使用select处理多个连接

        fd_set read_fds;

        FD_ZERO(&read_fds);

        FD_SET(server_fd, &read_fds);

        

        struct timeval tv = {1, 0};  // 1秒超时

        

        int activity = select(server_fd + 1, &read_fds, NULL, NULL, &tv);

        

        if (activity < 0 && errno != EINTR) {

            perror("select错误");

            break;

        }

        

        if (activity > 0 && FD_ISSET(server_fd, &read_fds)) {

            int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);

            if (client_fd < 0) {

                perror("accept失败");

                continue;

            }

            

            // 创建线程处理客户端

            pthread_t thread;

            int* client_fd_ptr = malloc(sizeof(int));

            *client_fd_ptr = client_fd;

            

            if (pthread_create(&thread, NULL, handle_client, client_fd_ptr) != 0) {

                perror("pthread_create失败");

                free(client_fd_ptr);

                close(client_fd);

                continue;

            }

            

            // 分离线程

            pthread_detach(thread);

        }

    }

    

    printf("\n服务器正在关闭...\n");

    close(server_fd);

    printf("服务器已关闭\n");

    

    return 0;

}

```

## 客户端完整实现

实现具有用户界面的计算器客户端：

```c

// calculator_client.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <netdb.h>

#include "calculator_protocol.h"

#define BUFFER_SIZE 4096

// 连接服务器

int connect_to_server(const char* hostname, int port) {

    int sockfd;

    struct sockaddr_in server_addr;

    struct hostent* server;

    

    // 创建socket

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0) {

        perror("socket创建失败");

        return -1;

    }

    

    // 解析主机名

    server = gethostbyname(hostname);

    if (server == NULL) {

        fprintf(stderr, "错误：无法解析主机名 %s\n", hostname);

        close(sockfd);

        return -1;

    }

    

    // 设置服务器地址

    memset(&server_addr, 0, sizeof(server_addr));

    server_addr.sin_family = AF_INET;

    memcpy(&server_addr.sin_addr.s_addr, server->h_addr, server->h_length);

    server_addr.sin_port = htons(port);

    

    // 连接服务器

    if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {

        perror("连接失败");

        close(sockfd);

        return -1;

    }

    

    printf("已连接到服务器 %s:%d\n", hostname, port);

    return sockfd;

}

// 发送计算请求

bool send_calculation_request(int sockfd, uint8_t operation, Operands* operands, uint32_t seq_num) {

    RequestMessage request;

    

    // 构建请求

    request.header.version = PROTOCOL_VERSION;

    request.header.operation = operation;

    request.header.error_code = 0;

    request.header.seq_num = seq_num;

    

    memcpy(&request.operands, operands, sizeof(Operands));

    

    // 序列化请求

    uint8_t buffer[BUFFER_SIZE];

    size_t buffer_len;

    

    if (!serialize_request(&request, buffer, &buffer_len)) {

        fprintf(stderr, "序列化请求失败\n");

        return false;

    }

    

    // 发送请求

    ssize_t bytes_sent = send(sockfd, buffer, buffer_len, 0);

    if (bytes_sent != buffer_len) {

        fprintf(stderr, "发送请求失败\n");

        return false;

    }

    

    return true;

}

// 接收响应

bool receive_calculation_response(int sockfd, double* result, char* error_msg) {

    uint8_t buffer[BUFFER_SIZE];

    

    // 接收头部

    ssize_t bytes_received = recv(sockfd, buffer, sizeof(ProtocolHeader), MSG_WAITALL);

    if (bytes_received != sizeof(ProtocolHeader)) {

        fprintf(stderr, "接收响应头部失败\n");

        return false;

    }

    

    // 解析头部

    ProtocolHeader header;

    memcpy(&header, buffer, sizeof(ProtocolHeader));

    header.seq_num = ntohl(header.seq_num);

    header.data_len = ntohl(header.data_len);

    

    // 接收数据部分

    if (header.data_len > 0) {

        bytes_received = recv(sockfd, buffer + sizeof(ProtocolHeader), header.data_len, MSG_WAITALL);

        if (bytes_received != header.data_len) {

            fprintf(stderr, "接收响应数据失败\n");

            return false;

        }

    }

    

    // 解析响应

    ResponseMessage response;

    if (!deserialize_response(buffer, sizeof(ProtocolHeader) + header.data_len, &response)) {

        fprintf(stderr, "解析响应失败\n");

        return false;

    }

    

    *result = response.result;

    strncpy(error_msg, response.error_msg, MAX_ERROR_MSG - 1);

    error_msg[MAX_ERROR_MSG - 1] = '\0';

    

    return true;

}

// 用户界面

void display_menu() {

    printf("\n=== 网络计算器 ===\n");

    printf("1. 加法 (+)\n");

    printf("2. 减法 (-)\n");

    printf("3. 乘法 (*)\n");

    printf("4. 除法 (/)\n");

    printf("5. 幂运算 (^)\n");

    printf("6. 平方根 (sqrt)\n");

    printf("0. 退出\n");

    printf("选择操作: ");

}

// 获取操作数

void get_operands(Operands* operands, uint8_t operation) {

    int count;

    

    switch (operation) {

        case OP_ADD:

        case OP_SUB:

        case OP_MUL:

            printf("请输入操作数个数 (2-%d): ", MAX_OPERANDS);

            scanf("%d", &count);

            if (count < 2) count = 2;

            if (count > MAX_OPERANDS) count = MAX_OPERANDS;

            break;

        

        case OP_DIV:

        case OP_POW:

            count = 2;

            break;

        

        case OP_SQRT:

            count = 1;

            break;

        

        default:

            count = 2;

            break;

    }

    

    operands->count = count;

    

    for (int i = 0; i < count; i++) {

        printf("请输入操作数 %d: ", i + 1);

        scanf("%lf", &operands->values[i]);

    }

}

int main(int argc, char* argv[]) {

    const char* server_host = "localhost";

    int server_port = 8888;

    

    // 解析命令行参数

    if (argc >= 2) {

        server_host = argv[1];

    }

    if (argc >= 3) {

        server_port = atoi(argv[2]);

    }

    

    // 连接服务器

    int sockfd = connect_to_server(server_host, server_port);

    if (sockfd < 0) {h7.ywaikang.com/sr.ywaikang.com/y6.nexgo.vip

        return EXIT_FAILURE;

    }

    

    uint32_t seq_num = 1;

    

    // 主循环

    while (1) {

        display_menu();

        

        int choice;

        scanf("%d", &choice);

        

        if (choice == 0) {

            break;

        }

        

        // 转换选择为操作类型

        uint8_t operation;

        switch (choice) {

            case 1: operation = OP_ADD; break;

            case 2: operation = OP_SUB; break;

            case 3: operation = OP_MUL; break;

            case 4: operation = OP_DIV; break;

            case 5: operation = OP_POW; break;

            case 6: operation = OP_SQRT; break;

            default:

                printf("无效选择\n");

                continue;

        }

        

        // 获取操作数

        Operands operands;

        get_operands(&operands, operation);

        

        // 发送请求

        if (!send_calculation_request(sockfd, operation, &operands, seq_num)) {

            printf("发送请求失败\n");

            continue;

        }

        

        // 接收响应

        double result;

        char error_msg[MAX_ERROR_MSG];

        

        if (!receive_calculation_response(sockfd, &result, error_msg)) {

            printf("接收响应失败\n");

            continue;

        }

        

        // 显示结果

        if (error_msg[0] != '\0') {

            printf("错误: %s\n", error_msg);

        } else {

            printf("结果: %.10g\n", result);

        }

        

        seq_num++;

    }

    

    close(sockfd);

    printf("连接已关闭\n");

    

    return EXIT_SUCCESS;

}

```

## 高级特性：连接池与异步通信

实现更高级的网络通信特性：

```c

// connection_pool.c

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>

#include <semaphore.h>

#define POOL_SIZE 10

#define MAX_RETRIES 3

typedef struct {

    int sockfd;

    time_t last_used;

    bool in_use;

    pthread_mutex_t lock;

} Connection;

typedef struct {

    Connection connections[POOL_SIZE];

    sem_t available_conns;

    pthread_mutex_t pool_lock;

    char* hostname;

    int port;

} ConnectionPool;

// 获取连接

Connection* acquire_connection(ConnectionPool* pool) {

    sem_wait(&pool->available_conns);

    

    pthread_mutex_lock(&pool->pool_lock);

    

    Connection* conn = NULL;

    for (int i = 0; i < POOL_SIZE; i++) {

        if (!pool->connections[i].in_use) {

            conn = &pool->connections[i];

            conn->in_use = true;

            conn->last_used = time(NULL);

            break;

        }

    }

    

    pthread_mutex_unlock(&pool->pool_lock);

    

    return conn;

}

// 释放连接

void release_connection(ConnectionPool* pool, Connection* conn) {

    pthread_mutex_lock(&conn->lock);

    conn->in_use = false;

    pthread_mutex_unlock(&conn->lock);

    

    sem_post(&pool->available_conns);

}

// 异步请求处理

typedef struct {

    int sockfd;

    RequestMessage request;

    void (*callback)(double result, const char* error_msg, void* user_data);

    void* user_data;

} AsyncRequest;

void* async_request_thread(void* arg) {

    AsyncRequest* req = (AsyncRequest*)arg;

    

    // 发送请求

    uint8_t buffer[BUFFER_SIZE];

    size_t buffer_len;

    

    if (serialize_request(&req->request, buffer, &buffer_len)) {

        send(req->sockfd, buffer, buffer_len, 0);

        

        // 接收响应

        double result;

        char error_msg[MAX_ERROR_MSG];

        

        if (receive_calculation_response(req->sockfd, &result, error_msg)) {

            // 调用回调函数

            req->callback(result, error_msg, req->user_data);

        } else {

            req->callback(0.0, "网络错误", req->user_data);

        }

    }

    

    free(req);

    return NULL;

}

void send_async_request(Connection* conn, RequestMessage* request,

                       void (*callback)(double, const char*, void*),

                       void* user_data) {

    AsyncRequest* async_req = malloc(sizeof(AsyncRequest));

    async_req->sockfd = conn->sockfd;

    async_req->request = *request;

    async_req->callback = callback;

    async_req->user_data = user_data;

    

    pthread_t thread;

    pthread_create(&thread, NULL, async_request_thread, async_req);

    pthread_detach(thread);

}

```

## 测试与验证工具

创建自动化测试工具验证协议实现：

```c

// protocol_test.c

#include <assert.h>

#include <string.h>

#include "calculator_protocol.h"

void test_protocol_serialization() {

    printf("测试协议序列化...\n");

    

    // 创建测试请求

    RequestMessage request;

    request.header.version = PROTOCOL_VERSION;

    request.header.operation = OP_ADD;

    request.header.error_code = 0;

    request.header.seq_num = 1;

    

    request.operands.count = 3;

    request.operands.values[0] = 1.5;

    request.operands.values[1] = 2.5;

    request.operands.values[2] = 3.5;

    

    // 序列化

    uint8_t buffer[BUFFER_SIZE];

    size_t buffer_len;

    

    assert(serialize_request(&request, buffer, &buffer_len));

    assert(buffer_len == sizeof(ProtocolHeader) + sizeof(double) * 3);

    

    // 反序列化

    RequestMessage deserialized;

    assert(deserialize_request(buffer, buffer_len, &deserialized));

    

    // 验证

    assert(deserialized.header.version == request.header.version);

    assert(deserialized.header.operation == request.header.operation);

    assert(deserialized.header.seq_num == request.header.seq_num);

    assert(deserialized.operands.count == request.operands.count);

    

    for (int i = 0; i < 3; i++) {

        assert(deserialized.operands.values[i] == request.operands.values[i]);

    }

    

    printf("协议序列化测试通过\n");

}

void test_validation() {

    printf("测试协议验证...\n");

    

    ProtocolHeader valid_header = {

        .version = PROTOCOL_VERSION,

        .operation = OP_ADD,

        .error_code = 0,

        .seq_num = 1,

        .data_len = 0

    };

    

    assert(validate_protocol_header(&valid_header));

    

    // 测试无效版本

    ProtocolHeader invalid_version = valid_header;

    invalid_version.version = 99;

    assert(!validate_protocol_header(&invalid_version));

    

    // 测试无效操作

    ProtocolHeader invalid_op = valid_header;

    invalid_op.operation = 99;

    assert(!validate_protocol_header(&invalid_op));

    

    printf("协议验证测试通过\n");

}

void test_calculation_validation() {

    printf("测试计算验证...\n");

    

    Operands valid_add = {.values = {1.0, 2.0, 3.0}, .count = 3};

    assert(validate_operands(OP_ADD, &valid_add));

    

    Operands invalid_div = {.values = {1.0, 0.0}, .count = 2};

    assert(!validate_operands(OP_DIV, &invalid_div));

    

    Operands invalid_sqrt = {.values = {-1.0}, .count = 1};

    assert(!validate_operands(OP_SQRT, &invalid_sqrt));

    

    printf("计算验证测试通过\n");

}

int main() {

    printf("=== 协议测试套件 ===\n\n");

    

    test_protocol_serialization();

    test_validation();

    test_calculation_validation();

    

    printf("\n所有测试通过！\n");

    return 0;

}

```

## 性能优化与错误处理

添加性能监控和健壮的错误处理：

```c

// performance_monitor.c

#include <sys/time.h>

#include <sys/resource.h>

typedef struct {

    long requests_processed;

    long total_bytes_sent;

    long total_bytes_received;

    double average_response_time_ms;

    struct timeval start_time;

} PerformanceStats;

void init_performance_stats(PerformanceStats* stats) {

    memset(stats, 0, sizeof(PerformanceStats));

    gettimeofday(&stats->start_time, NULL);

}

void update_performance_stats(PerformanceStats* stats, 

                             long bytes_sent, 

                             long bytes_received,

                             double response_time_ms) {

    stats->requests_processed++;

    stats->total_bytes_sent += bytes_sent;

    stats->total_bytes_received += bytes_received;

    

    // 更新平均响应时间（指数加权移动平均）

    stats->average_response_time_ms = 

        0.9 * stats->average_response_time_ms + 0.1 * response_time_ms;

}

void print_performance_report(const PerformanceStats* stats) {

    struct timeval current_time;

    gettimeofday(&current_time, NULL);

    

    double elapsed_seconds = (current_time.tv_sec - stats->start_time.tv_sec) +

                           (current_time.tv_usec - stats->start_time.tv_usec) / 1000000.0;

    

    printf("\n=== 性能报告 ===\n");

    printf("运行时间: %.2f 秒\n", elapsed_seconds);

    printf("处理请求数: %ld\n", stats->requests_processed);

    printf("发送字节数: %ld\n", stats->total_bytes_sent);

    printf("接收字节数: %ld\n", stats->total_bytes_received);

    printf("平均响应时间: %.2f ms\n", stats->average_response_time_ms);

    

    if (elapsed_seconds > 0) {

        double requests_per_second = stats->requests_processed / elapsed_seconds;

        double throughput_mbps = (stats->total_bytes_sent + stats->total_bytes_received) * 8 / elapsed_seconds / 1000000;

        

        printf("请求率: %.2f 请求/秒\n", requests_per_second);

        printf("吞吐量: %.2f Mbps\n", throughput_mbps);

    }

}

```

## 总结与最佳实践

通过实现网络计算器项目，总结TCP Socket编程的关键要点：

1. **协议设计原则**：

   - 固定头部结构便于解析

   - 包含版本字段支持协议演进

   - 序列号用于请求-响应匹配

   - 错误码标准化错误处理

2. **网络编程最佳实践**：

   - 使用线程池处理并发连接

   - 实现连接池复用TCP连接

   - 添加超时和重试机制

   - 实施完善的错误处理

3. **性能优化技巧**：

   - 批量处理减少网络往返

   - 使用select/poll/epoll处理多连接

   - 实现异步请求提升响应性

   - 添加压缩减少网络流量

4. **安全考虑**：

   - 验证输入数据防止缓冲区溢出

   - 实现认证机制（可扩展）

   - 添加请求频率限制

   - 考虑使用TLS加密通信

这个网络计算器项目展示了如何从零开始设计一个完整的网络应用，涵盖了协议设计、服务器实现、客户端开发、性能优化等关键环节，为构建更复杂的网络应用提供了坚实基础。