C++ TCP 服务器自定义协议设计与粘包问题解决方案

Decode 函数做了三件事：判断头部完整性、检查数据是否完整、解析并清理缓冲区。

2. 请求与响应结构

为了处理结构化数据，我们定义简单的序列化结构。

请求 (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 ...
};

3. 服务器核心架构

服务器采用多进程模型，每个连接由子进程处理。主循环监听端口，接受连接后 fork 子进程。

关键处理流程：

1. 子进程关闭监听 socket。
2. 循环读取数据到缓冲区 (inbuffer_stream)。
3. 每次读取后尝试解码，若成功则处理业务逻辑。
4. 若解码失败（数据不完整），继续等待下一次读取。

while (true) {
    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 if (s == 0) {
                break; // 客户端断开
            } else {
                break; // 错误
            }
        }
        close(sockfd);
        exit(0);
    }
    close(sockfd); // 父进程关闭当前连接的 fd
}

注意这里使用了回调函数 callback_ 来处理具体的业务逻辑（如计算器），实现了框架与业务的解耦。

完整代码示例

协议与数据结构

#include <string>
#define blank_sep " "
#define protocol_sep "\n"

class request {
public:
    int x_, y_;
    char op_;
    // ... constructor and destructor ...
    
    std::string serialization() {
        std::string str;
        str += std::to_string(x_);
        str += blank_sep;
        str += op_;
        str += blank_sep;
        str += std::to_string(y_);
        return str;
    }
    
    bool Deserialization(std::string &in) {
        size_t leftpos = in.find(blank_sep);
        if (leftpos == std::string::npos) return false;
        x_ = std::stoi(in.substr(0, leftpos));
        op_ = in[leftpos + 1];
        size_t rightpos = in.rfind(blank_sep);
        if (rightpos == std::string::npos) return false;
        y_ = std::stoi(in.substr(rightpos + 1));
        return true;
    }
};

class response {
public:
    int result_, code_;
    // ... constructor and destructor ...
    
    std::string serialization() {
        std::string str;
        str += std::to_string(result_);
        str += blank_sep;
        str += std::to_string(code_);
        return str;
    }
    
    bool Deserialization(std::string &in) {
        size_t pos = in.find(blank_sep);
        if (pos == std::string::npos) return false;
        result_ = std::stoi(in.substr(0, pos));
        code_ = std::stoi(in.substr(pos + 1));
        return true;
    }
};

// Encode/Decode functions as defined above

服务端主逻辑

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

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() {
        // Socket setup logic...
        std::cout << "init server successful!" << std::endl;
    }

    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 if (s == 0) {
                        break;
                    } else {
                        break;
                    }
                }
                close(sockfd);
                exit(0);
            }
            close(sockfd);
        }
    }
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;
}

客户端示例

#include <iostream>
#include <unistd.h>
#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);
    
    std::string inbuffer_stream;
    for (int cnt = 1; cnt <= 10; ++cnt) {
        int x = rand() % 100 + 1;
        int y = rand() % 100;
        char oper = '+'; // Simplified for demo
        
        request req(x, y, oper);
        std::string package = req.serialization();
        package = Encode(package);
        
        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 编程的本质不是收发数据，而是如何正确解析数据的边界。通过设计'长度 + 内容'的应用层协议，配合缓冲区累积策略，我们可以可靠地处理粘包和半包问题，构建稳定的网络服务。