Linux 下基于 Socket 的 HTTP 服务器实现与协议解析

常见状态码

• 200 (OK)：请求成功。
• 404 (Not Found)：资源未找到。
• 403 (Forbidden)：禁止访问。
• 302 (Redirect)：临时重定向。
• 504 (Bad Gateway)：网关超时。

HTTP 常见 Header

模拟实现 HTTP 服务器

为了深入理解网络编程，我们尝试用 C++ 手写一个简单的 HTTP 服务器。项目目录结构大致如下：

核心代码实现

这里将关键模块拆分为几个文件，便于维护。

Socket 封装 (socket.hpp)

封装了基本的 Socket 操作，包括创建、绑定、监听和接受连接。

// socket.hpp
#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include "log.hpp"
#include <string.h>
#include <unistd.h>
using namespace std;

Log lg;
const int backlog = 10;
enum { SocketErr = 2, BindErr, ListenErr };

class Sock {
public:
    Sock() {}
    ~Sock() {}
    
    void Socket() {
        sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd_ < 0) {
            lg(Fatal, "socket error, strerror: %s, errno: %d", strerror(errno), errno);
            exit(SocketErr);
        }
    }

    void Bind(uint16_t port) {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY;
        if (bind(sockfd_, (struct sockaddr*)&local, sizeof(local)) < 0) {
            lg(Fatal, "Bind error, strerror: %s, errno: %d", strerror(errno), errno);
            exit(BindErr);
        }
    }

    void Listen() {
        if (listen(sockfd_, backlog) < 0) {
            lg(Fatal, "Listen Error, strerror: %s, errno: %d", strerror(errno), errno);
            exit(ListenErr);
        }
    }

    int Accept(std::string* ip, uint16_t* port) {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int newfd = accept(sockfd_, (struct sockaddr*)&peer, &len);
        if (newfd < 0) {
            lg(Warning, "accept error, strerror: %s, errno: %d", strerror(errno), errno);
            return -1;
        }
        char ipstr[64];
        inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr));
        *ip = ipstr;
        *port = ntohs(peer.sin_port);
        return newfd;
    }

    bool Connect(const string& ip, const uint16_t& port) {
        struct sockaddr_in peer;
        memset(&peer, 0, sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(port);
        inet_pton(AF_INET, ip.c_str(), &(peer.sin_addr));
        int n = connect(sockfd_, (struct sockaddr*)&peer, sizeof(peer));
        if (n < 0) {
            cerr << "Connect to" << ip << ":" << port << endl;
            return false;
        }
        return true;
    }

    void Close() { close(sockfd_); }
    int Fd() { return sockfd_; }
private:
    int sockfd_;
};

服务器逻辑 (server.hpp)

包含线程管理、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;
            // std::cout << buffer << endl;
            HttpResponse rep;
            rep.Deserialize(buffer);
            rep.Parse();
            rep.DebugPrint();
            std::string text = ReadHtmlContent(rep.file_path);
            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 文件作为响应内容。注意将 IP 地址修改为本地回环地址以便测试。

<!-- 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/a/b/hello.html">到第二张网页</a>
<a href="http://127.0.0.1:8080/c/d/hello2.html">到第三张网页</a>
</body>
</html>

<!-- hello.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">回到首页</a>
<a href="http://127.0.0.1:8080/c/d/hello2.html">到第三张网页</a>
</body>
</html>

主程序入口 (server.cc)

// server.cc
#include <iostream>
#include "HttpServer.hpp"
using namespace std;

int main(int argc, char* argv[]) {
    if (argc != 2) exit(1);
    HttpServer* svr = new HttpServer(stoi(argv[1]));
    svr->start();
    return 0;
}

运行与验证

编译并启动服务端，输入端口号即可。

打开浏览器访问 ip:端口号。

点击链接跳转，观察页面变化。

使用终端工具查看浏览器发送的实际请求报文。

可以看到域名和路径的变化，这证实了服务器正确解析了请求并返回了对应文件。

Cookie 机制

为什么第一次访问网站需要登录，第二次却不需要？因为浏览器保存了 Cookie。服务器分配了一个 ID，每次请求携带该 ID，服务器据此确认用户身份。

Cookie 信息可在浏览器开发者工具中查看，删除后需重新登录。

流程简述：

1. 客户端首次发送账号密码。
2. 服务器建立 Cookie 并分配 ID。
3. 后续访问携带 Cookie 和 ID，服务器查库验证。

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

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

刷新浏览器，左上角即可查看到设置的 Cookie 信息。