Linux 网络编程实战：HTTP 协议解析与服务器实现

核心逻辑

主服务器类负责启动监听、接受连接并创建线程处理每个请求。这里我们使用简单的多线程模型。

// server.hpp
#pragma once
#include <iostream>
#include "Socket.hpp"
#include <string>
#include <pthread.h>
#include <fstream>
#include <vector>
#include <sstream>
#include <sys/types.h>
#include <sys/socket.h>
#include <unordered_map>

std::string blank_line = "\r\n";
std::string wwwroot = "./wwwroot";
std::string homepage = "index.html";

class HttpServer;

class ThreadData {
public:
    ThreadData(int sockfd, HttpServer* hs) : _sockfd(sockfd), _hs(hs) {}
public:
    int _sockfd;
    HttpServer* _hs;
};

class HttpResponse {
public:
    void Deserialize(std::string req) {
        while (true) {
            std::size_t pos = req.find(blank_line);
            if (pos == std::string::npos) break;
            std::string temp = req.substr(0, pos);
            if (temp.empty()) // 空行
                break;
            vc.push_back(temp);
            req.erase(0, pos + blank_line.size());
        }
        text += req;
    }

    void Parse() {
        std::stringstream ss(vc[0]);
        ss >> method >> url >> version;
        file_path = wwwroot;
        if (url == "/" || url == "index.html") {
            file_path += "/";
            file_path += homepage; // wwwroot/index.html
        } else {
            file_path += url; // wwwroot/a/b/t/t
        }
    }

    void DebugPrint() {
        for (auto line : vc) {
            std::cout << line << std::endl;
            std::cout << "------------" << std::endl;
        }
        std::cout << "method: " << method << std::endl;
        std::cout << "url: " << url << std::endl;
        std::cout << "version: " << version << std::endl;
        std::cout << "file_path: " << file_path << std::endl;
        std::cout << "text: " << text << std::endl;
    }

public:
    vector<string> vc;
    string text;
    std::string method;
    std::string url;
    std::string version;
    std::string file_path;
};

class HttpServer {
public:
    HttpServer(uint16_t port) : _port(port) {}

    void start() {
        _listen.Socket();
        _listen.Bind(_port);
        _listen.Listen();
        lg(Info, "server create success");
        for (;;) {
            std::string clientip;
            uint16_t port;
            int sockfd = _listen.Accept(&clientip, &port);
            lg(Info, "get a newfd:%d", sockfd);
            pthread_t tid;
            ThreadData* td = new ThreadData(sockfd, this);
            pthread_create(&tid, nullptr, ThreadRun, td);
        }
    }

    static std::string ReadHtmlContent(const std::string& htmlpath) {
        std::ifstream in(htmlpath);
        if (!in.is_open()) {
            return "404";
        }
        std::string content;
        std::string line;
        while (getline(in, line)) {
            content += line;
        }
        in.close();
        return content;
    }

    static void HandlerHttp(int sockfd) {
        char buffer[10240];
        ssize_t n = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
        if (n > 0) {
            buffer[n] = 0;
            HttpResponse rep;
            rep.Deserialize(buffer);
            rep.Parse();
            rep.DebugPrint();
            std::string text = ReadHtmlContent(rep.file_path);
            // 注意：实际生产中应区分 200 和 404 状态码
            std::string response_line = "HTTP/1.0 200 OK\r\n";
            std::string response_header = "Content-Length: ";
            response_header += std::to_string(text.size());
            std::string response = response_line;
            response += response_header;
            response += "\r\n";
            response += blank_line;
            response += text;
            send(sockfd, response.c_str(), response.size(), 0);
        }
        close(sockfd);
    }

    static void* ThreadRun(void* args) {
        pthread_detach(pthread_self());
        ThreadData* td = static_cast<ThreadData*>(args);
        HandlerHttp(td->_sockfd);
        close(td->_sockfd);
        delete td;
        return nullptr;
    }

    Sock _listen;
    uint16_t _port;
};

前端文件示例

为了让服务器能返回内容，我们需要准备一些 HTML 文件放在 wwwroot 目录下。

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Document</title></head>
<body>
<h1>这个是我们的首页</h1>
<a href="http://127.0.0.1:8080/hello.html">到第二张网页</a>
</body>
</html>

日志模块

为了方便调试，我们还需要一个简单的日志工具类。

// log.hpp
#pragma once
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

#define SIZE 1024
#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4
#define Screen 1
#define Onefile 2
#define Classfile 3
#define Logfile "log.txt"

class Log {
public:
    Log() { printmethod = Screen; path = "./log/"; mkdir(path.c_str(), 0777); }
    void Enable(int method) { printmethod = method; }
    string levelToString(int level) {
        switch (level) {
            case Info: return "Info";
            case Debug: return "Debug";
            case Warning: return "Warning";
            case Error: return "Error";
            case Fatal: return "Fatal";
        }
        return "Unknown";
    }

    void operator()(int level, const char* format, ...) {
        time_t t = time(nullptr);
        struct tm* ctime = localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]",
                 levelToString(level).c_str(),
                 ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
                 ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
        va_list s;
        va_start(s, format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);
        char logtxt[SIZE * 2];
        snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);
        printlog(level, logtxt);
    }

    void printlog(int level, const string& logtxt) {
        switch (printmethod) {
            case Screen: cout << logtxt << endl; break;
            case Onefile: printOnefile(Logfile, logtxt); break;
            case Classfile: printClassfile(level, logtxt); break;
        }
    }

    void printOnefile(const string& failname, const string& logtxt) {
        string _failname = path + failname;
        int fd = open(_failname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
        if (fd < 0) return;
        write(fd, logtxt.c_str(), logtxt.size());
        close(fd);
    }

    void printClassfile(int level, const string& logtxt) {
        string _failname = Logfile;
        _failname += ".";
        _failname += levelToString(level);
        printOnefile(_failname, logtxt);
    }

    ~Log() {}

private:
    int printmethod;
    string path;
};

启动与测试

编译并运行程序，指定端口号作为参数：

g++ server.cc -lpthread -o server
./server 8080

打开浏览器输入 http://127.0.0.1:8080，即可看到首页内容。点击链接可以验证页面跳转是否正常。你也可以使用终端工具查看发送的请求报文，确认协议格式是否符合预期。

Cookie 机制

为什么第一次访问网站需要登录，第二次却不需要？这是因为浏览器帮我们记住了账户信息，这些信息存储在 Cookie 中。此外，服务器会分配一个 Session ID，每次访问时浏览器都会携带 Cookie 和 ID 让服务器确认账号信息。

Cookie 信息可以在浏览器的开发者工具中查看。如果删除 Cookie，通常需要重新登录。

在我们的服务器代码中加入 Cookie 设置：

response_header += "Set-Cookie: name=haha&&password=123456\r\n";

这样客户端收到响应后，就会保存该 Cookie，并在后续请求中自动带上。这实现了简单的会话保持功能。

通过以上步骤，我们完成了一个基于 Linux Socket 的简易 HTTP 服务器实现，涵盖了从协议解析到实际部署的关键环节。在实际生产环境中，还需考虑并发性能、安全性以及更复杂的路由逻辑。