用C编写Web服务器：TCP Socket读取POST请求的最优方案

核心问题解决思路 #

你当前的问题在于固定长度缓冲区可能混入请求体，导致后续解析复杂且低效。最优的方式是基于HTTP协议的请求头结束标记\r\n\r\n来拆分请求头与请求体，而非依赖固定长度。

具体实现步骤 #

• 动态读取并定位请求头边界
  用一个可扩容的缓冲区循环读取Socket数据，每次读取后检查缓冲区中是否存在\r\n\r\n（HTTP请求头与体的分隔符）。一旦找到这个标记，就可以精准拆分出完整的请求头，缓冲区中标记之后的内容就是请求体的起始部分。

  • 初始缓冲区建议设为4KB或8KB（平衡系统调用次数与内存占用），如果缓冲区满了还没找到分隔符，就用realloc扩容。

• 解析Content-Length并读取完整请求体

  1. 从拆分出的请求头中提取Content-Length字段的值，计算请求体的总长度。
  2. 计算当前缓冲区中已有的请求体字节数（总读取字节数减去请求头及分隔符的长度）。
  3. 动态分配刚好能容纳整个请求体的内存，先把缓冲区中已有的请求体部分拷贝进去，再从Socket读取剩余的请求体字节，直到满足Content-Length的要求。

代码示例 #

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define INIT_BUF_SIZE 4096

int handle_post_request(int client_sock) {
    // 初始化动态缓冲区
    char* buf = malloc(INIT_BUF_SIZE);
    if (!buf) return -1;
    size_t buf_capacity = INIT_BUF_SIZE;
    size_t total_read = 0;
    ssize_t read_bytes;
    char* header_sep = NULL;

    // 循环读取直到找到请求头结束标记
    while ((read_bytes = read(client_sock, buf + total_read, buf_capacity - total_read)) > 0) {
        total_read += read_bytes;
        header_sep = strstr(buf, "\r\n\r\n");
        if (header_sep) break;

        // 缓冲区已满，扩容为原来的2倍
        if (total_read == buf_capacity) {
            char* new_buf = realloc(buf, buf_capacity * 2);
            if (!new_buf) {
                free(buf);
                return -1;
            }
            buf = new_buf;
            buf_capacity *= 2;
        }
    }

    if (!header_sep) {
        free(buf);
        return -1; // 未找到合法的请求头分隔符
    }

    // 解析Content-Length
    char* content_len_ptr = strstr(buf, "Content-Length: ");
    if (!content_len_ptr) {
        free(buf);
        return -1; // POST请求缺少Content-Length，按需处理
    }
    content_len_ptr += strlen("Content-Length: ");
    size_t content_len = atoi(content_len_ptr);

    // 计算已读取的请求体长度
    size_t existing_body_len = total_read - (header_sep - buf + 4); // +4跳过\r\n\r\n
    size_t remaining_body_len = content_len - existing_body_len;

    // 分配请求体缓冲区
    char* body_buf = malloc(content_len);
    if (!body_buf) {
        free(buf);
        return -1;
    }

    // 拷贝已有的请求体部分
    memcpy(body_buf, header_sep + 4, existing_body_len);

    // 读取剩余的请求体数据
    while (remaining_body_len > 0) {
        read_bytes = read(client_sock, body_buf + existing_body_len, remaining_body_len);
        if (read_bytes <= 0) {
            free(buf);
            free(body_buf);
            return -1;
        }
        existing_body_len += read_bytes;
        remaining_body_len -= read_bytes;
    }

    // 这里添加请求体的处理逻辑，比如解析、存储等
    printf("POST请求体长度：%zu\n内容：\n%.*s\n", content_len, (int)content_len, body_buf);

    // 释放内存
    free(buf);
    free(body_buf);
    return 0;
}

效率优化点 #

• 减少系统调用：用较大的缓冲区批量读取数据，避免频繁调用read。
• 避免冗余拷贝：直接在读取缓冲区中解析Content-Length，无需额外拷贝请求头。
• 按需内存分配：请求体缓冲区大小严格匹配Content-Length，避免内存浪费。

注：如果需要支持Transfer-Encoding: chunked的POST请求，需要额外实现分块解析逻辑，但大部分场景下Content-Length的处理已足够覆盖需求。

内容的提问来源于stack exchange，提问作者Hououin_kyouma