手写 C++ TCP 服务器：自定义协议与粘包处理

这里的关键是判断缓冲区是否包含完整的头部和数据。如果不够，返回 false，等待下一次 read 补充数据。

请求与响应结构

Request (请求):

class request {
public:
    int x_;
    int y_;
    char op_;
    // ... serialization/deserialization methods ...
};

Response (响应):

class response {
public:
    int result_;
    int code_; // 0:成功，1:除0，2:取模0，3:非法操作
    // ... serialization/deserialization methods ...
};

服务器核心逻辑

服务器接收到数据后，会不断循环读取并尝试解码。只有当 Decode 成功返回完整报文时，才进行业务逻辑处理。

while (true) {
    int sockfd = listenfd_.Accept(&client_port, &client_ip);
    if (fork() == 0) {
        while (1) {
            char buffer[1280];
            ssize_t s = read(sockfd, buffer, sizeof buffer - 1);
            if (s > 0) {
                inbuffer_stream += buffer;
                while (true) {
                    std::string info = callback_(inbuffer_stream);
                    if (info.empty()) break;
                    write(sockfd, info.c_str(), info.size());
                }
            } else {
                break;
            }
        }
        close(sockfd);
        exit(0);
    }
}

注意这里使用了 fork() 创建子进程处理每个连接，且主进程忽略 SIGCHLD 和 SIGPIPE 信号，避免僵尸进程和断连报错。

完整代码示例

为了便于理解，以下是整合后的服务端与客户端关键代码。

服务端 (TcpServer.cpp)

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string>
#include <functional>

// Socket 封装类
enum error { SocketErr = 2, BindErr, ListenErr, ConnectErr };

class Socket {
public:
    Socket() { sockfd_ = socket(AF_INET, SOCK_STREAM, 0); }
    void Bind(uint16_t &port, std::string &ip) {
        struct sockaddr_in server;
        server.sin_family = AF_INET;
        server.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &server.sin_addr);
        bind(sockfd_, (struct sockaddr *)&server, sizeof(server));
    }
    void Listen() { listen(sockfd_, 10); }
    int Accept(uint16_t *client_port, std::string *client_ip) {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int fd = accept(sockfd_, (struct sockaddr *)&client, &len);
        *client_port = ntohs(client.sin_port);
        char ip[64];
        inet_ntop(AF_INET, &client.sin_addr, ip, sizeof ip);
        *client_ip = ip;
        return fd;
    }
    int fd() { return sockfd_; }
    ~Socket() { close(sockfd_); }
private:
    int sockfd_;
};

// 计算逻辑服务
class CalculatorServer {
public:
    response CalculatorHandler(const request &req) {
        response res(0, 0);
        switch (req.op_) {
            case '+': res.result_ = req.x_ + req.y_; break;
            case '-': res.result_ = req.x_ - req.y_; break;
            case '*': res.result_ = req.x_ * req.y_; break;
            case '/': if (req.y_ == 0) { res.code_ = 1; break; } res.result_ = req.x_ / req.y_; break;
            case '%': if (req.y_ == 0) { res.code_ = 2; break; } res.result_ = req.x_ % req.y_; break;
            default: res.code_ = 3; break;
        }
        return res;
    }
    std::string Calculator(std::string& s) {
        std::string content;
        if (!Decode(s, &content)) return "";
        request req;
        if (!req.Deserialization(content)) return "";
        response res = CalculatorHandler(req);
        return Encode(res.serialization());
    }
};

using func_t = std::function<std::string(std::string &)>;

class TcpServer {
public:
    TcpServer(uint16_t port, std::string ip, func_t callback) : port_(port), ip_(ip), callback_(callback) {}
    void InitServer() {
        listenfd_.Bind(port_, ip_);
        listenfd_.Listen();
    }
    void start() {
        signal(SIGCHLD, SIG_IGN);
        signal(SIGPIPE, SIG_IGN);
        while (true) {
            uint16_t client_port;
            std::string client_ip;
            int sockfd = listenfd_.Accept(&client_port, &client_ip);
            if (sockfd < 0) continue;
            if (fork() == 0) {
                listenfd_.Close();
                std::string inbuffer_stream;
                while (1) {
                    char buffer[1280];
                    ssize_t s = read(sockfd, buffer, sizeof buffer - 1);
                    if (s > 0) {
                        buffer[s] = 0;
                        inbuffer_stream += buffer;
                        while (true) {
                            std::string info = callback_(inbuffer_stream);
                            if (info.empty()) break;
                            write(sockfd, info.c_str(), info.size());
                        }
                    } else {
                        break;
                    }
                }
                close(sockfd);
                exit(0);
            }
        }
    }
private:
    Socket listenfd_;
    uint16_t port_;
    std::string ip_;
    func_t callback_;
};

int main(int argc, char* argv[]) {
    if (argc != 3) return 0;
    uint16_t server_port = std::atoi(argv[2]);
    std::string server_ip = argv[1];
    CalculatorServer cal;
    TcpServer* ser = new TcpServer(server_port, server_ip, std::bind(&CalculatorServer::Calculator, &cal, std::placeholders::_1));
    ser->InitServer();
    ser->start();
    return 0;
}

客户端 (Client.cpp)

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <ctime>
#include "Protocol.hpp"
#include "Socket.hpp"

int main(int argc, char *argv[]) {
    if (argc != 3) return 0;
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    Socket sockfd;
    sockfd.Connect(serverport, serverip);
    srand(time(nullptr) ^ getpid());
    const std::string opers = "+-*/%";
    std::string inbuffer_stream;
    for (int cnt = 1; cnt <= 10; ++cnt) {
        int x = rand() % 100 + 1;
        usleep(1234);
        int y = rand() % 100;
        usleep(4321);
        char oper = opers[rand() % opers.size()];
        request req(x, y, oper);
        std::string package = Encode(req.serialization());
        write(sockfd.fd(), package.c_str(), package.size());
        char buffer[128];
        ssize_t n = read(sockfd.fd(), buffer, sizeof(buffer) - 1);
        if (n > 0) {
            buffer[n] = 0;
            inbuffer_stream += buffer;
            std::string content;
            bool r = Decode(inbuffer_stream, &content);
            if (r) {
                response resp;
                resp.Deserialization(content);
                resp.DebugPrint();
            }
        }
        sleep(1);
    }
    sockfd.Close();
    return 0;
}

总结

TCP 编程的本质不是收发数据，而是如何正确解析数据的边界。通过设计包含长度头的自定义协议，我们可以从容应对粘包和拆包问题，确保应用层数据的完整性。在实际开发中，根据业务复杂度选择合适协议（如 TLV、JSON 等）是关键。