最新资讯

size_t remaining = data.size() - head.size();
if (remaining < content_length) {
    std::string body = data.substr(data.find("

") + 4, remaining);
    int to_read = content_length - remaining;
    char body_buffer[BUFFER_SIZE];
    while (to_read > 0) {
        ssize_t read_bytes = recv(socketfd, body_buffer, 
                                   std::min(BUFFER_SIZE - 1, to_read), 0);
        if (read_bytes <= 0) {
            lg.logmessage(Fatal, "recv error");
            return false;
        }
        body.append(body_buffer, read_bytes);
        to_read -= read_bytes;
    }
    hr.text = body;
} else {
    hr.text = data.substr(data.find("

") + 4, content_length);
}

至此，我们已获取完整的请求行、请求头及请求正文。接下来进行反序列化，将这些字节流转换为结构化的对象，便于后续处理。定义http_request 结构体，其成员包括：

• std::unordered_map header ：存储请求头的键值对。
• std::string method 、url 、http_version ：存储请求行解析出的方法、URL 和协议版本。
• std::string text ：存储请求正文。

class Http_Request
{
public:
//...    
    public:
        std::vector<std::string> header;
        std::string text;
        std::string method;
        std::string url;
        std::string http_version;
};

该结构体提供反序列化成员函数Deserialization ，其功能为解析head 字符串，提取请求行各部分并填充至成员变量，同时将请求头键值对存入哈希表。函数返回bool 类型，表示解析成功与否。

最终，Get_httpRequest 函数在成功读取并解析请求后，调用hr.Deserialization(head) 进行反序列化，并返回结果。

bool Get_HttpRequest(size_t socketfd, Http_Request& hr) {
    std::string data;
    char buffer[BUFFER_SIZE];
    while (true) {
        ssize_t read_bytes = recv(socketfd, buffer, BUFFER_SIZE - 1, 0);
        if (read_bytes <= 0) {
            lg.logmessage(Fatal, "recv error");
            return false;
        }
        data.append(buffer, read_bytes);
        if (data.find("

") != std::string::npos) {
            break;
        }
    }
    std::string head = data.substr(0, data.find("

") + 4);
    size_t pos = data.find("Content-Length:");
    if (pos != std::string::npos) {
        ssize_t endpos = head.find("
", pos);
        std::string content_length_str = head.substr(pos + 15, endpos - pos - 15);
        size_t content_length = std::stoi(content_length_str);
        size_t remaining = data.size() - head.size();
        if (remaining < content_length) {
            std::string body = data.substr(data.find("

") + 4, remaining);
            int to_read = content_length - remaining;
            char body_buffer[BUFFER_SIZE];
            while (to_read > 0) {
                ssize_t read_bytes = recv(socketfd, body_buffer,
                                           std::min(BUFFER_SIZE - 1, to_read), 0);
                if (read_bytes <= 0) {
                    lg.logmessage(Fatal, "recv error");
                    return false;
                }
                body.append(body_buffer, read_bytes);
                to_read -= read_bytes;
            }
            hr.text = body;
        } else {
            hr.text = data.substr(data.find("

") + 4, content_length);
        }
    }
    bool res = hr.Deserialization(head);
    hr.debugprint();
    return res;
}

调用Get_httpRequest 时，需预先定义http_request 对象作为输出型参数，连同已连接套接字的文件描述符一并传入。

接下来是关于http_request 类的Deserialization 函数。该函数的功能是提取请求行和请求头的键值对，并将键值对保存到名为header的哈希表中。由于请求行与请求头之间由回车换行符（CRLF）分隔，首先需要分割出请求行及各请求头字段。具体实现思路是定义一个整型变量start，用于记录分割的起始位置；同时定义一个整型变量end，用于定位回车换行符。

分割逻辑被置于一个循环中。进入循环之前，会定义一个名为_header 的std::vector 数组，该数组用于临时保存分割后的请求行及每个请求头字段（键值对组成的整行字符串），start初始值设为0，随后调用find函数查找子串" " ，该函数接收两个参数：待查找的子串及起始查找位置。若返回std::string::npos ，表示未找到回车换行符，说明客户端构建的请求报文有误，此时返回false。若查找成功，则通过substr函数分割出子串（不包含换行符），并将其插入_header 数组。接着更新start和end的位置，将start移动到所找到的子串" " 之后，即start = end + 2，然后重复上述过程。

需注意的是，请求头部分末尾包含一个空行。当start移动到最后一个回车换行符之后的字符，即空行" " 的起始位置时，再次调用find函数将返回该位置。此时通过substr分割出的子串为空，表明所有请求行和请求头键值对已分割并保存至数组，循环结束。

接下来，我们需要将分割出的请求头键值对插入到哈希表header 中。由于数组_header 的第一个元素是请求行，因此从第二个元素开始遍历。每一行的键和值之间由冒号分隔，首先调用find 函数查找冒号的位置，若未找到（返回npos），则说明客户端构建的请求报文格式错误，函数返回false 。接着，通过substr 分割出冒号前的部分作为键（key）。

冒号之后可能存在一个或多个空格，之后才是值的起始位置。由于某些客户端构建的请求报文可能不规范，空格数量不定，我们通过一个循环跳过所有空白字符，定位到值的起始索引。随后，再次调用substr 分割出剩余部分作为值（value）。最后，将键值对插入到哈希表header 中。

for (size_t i = 1; i < _header.size(); i++)
{
    std::string line = _header[i];
    size_t pos = line.find(":");
    if (pos == std::string::npos)
    {
        return false;
    }
    std::string key = line.substr(0, pos);
    size_t val_start = pos + 1;
    // 跳过冒号后的空白字符,issspace接收一个字符，如果当前字符为空格等空白字符，返回为true
    while (val_start < line.size() && std::isspace(line[val_start]))
    {
        val_start++;
    }
    std::string value = line.substr(val_start);
    headers[key] = value;
}

最后的任务是解析已保存至数组的请求行，即数组的第一个元素。请注意，分割时已去除末尾的回车换行符。请求行由三个部分组成，每部分以空格分隔，依次是请求方法、URL和协议版本。

对于请求行的解析，常见有两种实现方式。第一种做法是定义两个变量，分别记录分割的起始位置和结束位置（即空格所在位置）。具体步骤是：首先调用find 函数定位第一个空格，通过substr 分割出请求方法；然后将起始位置移动到该空格之后，再次调用find 函数查找下一个空格，分割出URL；最后将起始位置移动到第二个空格之后，直接分割剩余部分作为协议版本。

std::string first_line = header[0];
size_t space1 = first_line.find(" ");
if (space1 == std::string::npos)
{
    return false;
}
method = first_line.substr(0, space1);
size_t space2 = first_line.find(" ", space1 + 1);
if (space2 == std::string::npos)
{
    return false;
}
url = first_line.substr(space1 + 1, space2 - space1 - 1);
http_version = first_line.substr(space2 + 1);

但需注意，某些客户端构建的请求报文格式可能不规范，例如各部分之间的空格数量可能不止一个，这会导致解析失败。因此，更推荐的做法是使用stringstream 。

在C++中，字符串被抽象为流对象。stringstream 内部通过缓冲区存储字符串，并重载了<< 和>> 运算符。stringstream 对象内部维护两个独立的指针：读指针和写指针，两者默认均指向缓冲区起始位置。调用>> 运算符时，会从读指针当前位置开始解析：若读指针指向分隔符（如空格），则跳过该分隔符，直至遇到非分隔符字符；然后持续读取，直到再次遇到分隔符，将这段子串提取到>> 操作符右侧的string 对象中。若读指针到达缓冲区末尾，会设置EOF标志，后续提取操作将失败。

stringstream要跳过的分割符：

而<< 运算符用于向缓冲区写入字符串，从写指针当前位置开始拼接。需要注意，应避免在同一stringstream 对象上混用读、写操作，因为写入操作会从写指针位置开始覆盖缓冲区内容。若流对象已初始化（缓冲区中已有数据），写入新字符串会覆盖原有数据。

#include 
#include 
int main()
{
    std::stringstream ss("hello world wz
 ");
    std::string a, b, c, d;
    ss >> a >> b >> c;
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;
    ss << "wz";
    std::cout << "Buffer now: " << ss.str() << std::endl; 
    return 0;
}

stringstream 提供了str() 成员函数：无参版本返回临时字符串对象；有参版本会清空缓冲区并重新设置内容，同时将读写指针重置到开头，但不会清除EOF标志。如需清除EOF标志，需额外调用clear() 函数。

  bool Deserialization(std::string& head)
        {
        size_t start=0;
        std::vector<std::string>_header;
                while(true)
        {   
            std::string line;
            size_t end=head.find("
",start);
            if(end==std::string::npos)
            {   
                return false;
            }
            line=head.substr(start,end-start);
            if(line.empty())
            {   
                break;
            }
            start=end+2;
            _header.push_back(line);
        }
        if(_header.size()<1)
        {
            return false;
        }
        for(size_t i=1;i<_header.size();i++)
        {
            std::string line=_header[i];
            ssize_t pos=line.find(":");
            if(pos==std::string::npos)
            {
                return false;
            }
            std::string key=line.substr(0,pos);
            size_t val_start=pos+1;
            while(val_start<line.size() && std::isspace(line[val_start]))
            {
                val_start++;
            }
            std::string value=line.substr(val_start);
            headers[key]=value;
        }
        std::string first_line=_header[0];
        std::stringstream ss(first_line);
        ss>>method>>url>>http_version;
        return true;
        }

为便于调试，在http_request类中还定义了一个debugprint函数。该函数用于打印请求报文，由于请求报文为文本格式，可直接阅读。请求行、请求头及请求正文均已保存至对应变量中，因此只需按HTTP报文的格式打印各部分即可。

 void debugprint()
    {
         std::cout<<std::endl;
        std::cout<<method<<" "<<url<<" "<<http_version<<std::endl;
        for(auto it=headers.begin();it!=headers.end();it++)
        {
            std::cout<<it->first<<": "<<it->second<<std::endl;
        }
        std::cout<<std::endl;
        std::cout<<text<<std::endl;
        std::cout<<std::endl;
    }

因此，在http_Get_HttpRequest函数中调用反序列化函数后，特意调用了debugprint函数，以输出客户端发送的请求报文内容，辅助验证解析结果。

成功获取完整TCP报文段并反序列化后，各字段将解析并存储到一个http_request 对象中，该过程通过调用Get_HttpRequest 函数实现。若函数返回false ，则表示获取完整TCP报文失败或反序列化过程出现错误，此时记录日志并退出处理流程；若返回true ，则进入请求报文处理阶段。

在反序列化过程中，请求行的各个参数已被解析并存入http_request 对象的对应字段，后续逻辑进入业务分发阶段。系统依据method 字段判断请求类型：若为GET方法，则优先尝试静态资源映射；若为POST方法，则触发动态业务逻辑处理。通过这种基于HTTP方法的分流机制，确保不同类型的请求能够被路由至相应的处理模块。

为此，这里定义了两个处理函数模块：Http_Get_Handler 与Http_Post_Handler 。根据http_request 对象中的method 字段，调用对应的处理函数。这两个函数的返回值为srting 类型，即构造好的响应报文。获取响应报文后，调用send 接口将其发送回客户端，随后关闭套接字并正常结束当前连接处理流程。

void run()
{
    Http_Request hr;
    bool get_result = Get_HttpRequest(socketfd, hr);
    if (get_result == false)
    {
        lg.logmessage(Fatal, "get http request error");
        close(socketfd);
        return;
    }
    

std::string res;
if (hr.method == "GET")
{
    res = Http_Get_Handler(hr);
}
else if (hr.method == "POST")
{
    res = Http_Post_Handler(hr);
}
else
{
    lg.logmessage(warning, "unsupported method: %s", hr.method.c_str());
    close(socketfd);
    return;
}

int send_bytes = send(socketfd, res.c_str(), res.size(), 0);
if (send_bytes < 0)
{
    lg.logmessage(Fatal, "send error");
    close(socketfd);
    return;
}

close(socketfd);

}

由于浏览器与服务端通信的场景中，绝大多数请求为GET或POST方法，若接收到其它类型的HTTP方法请求，此处将直接记录错误日志，随后关闭套接字并退出该连接的处理流程。

首先介绍的是Http_Get_Handler 处理模块。GET请求通常用于从服务器获取静态资源，即文件。在此上下文中，URL对应于服务器文件系统下的一个相对路径。我们以服务器所在目录作为根目录，将URL映射为该目录下的相对路径。具体而言，映射操作通过字符串拼接实现。为此，我定义了一个全局字符串变量path ，其值为./wwwroot 。通过将URL与path 拼接，我们可以在服务器目录下创建名为wwwroot 的文件夹，用于存放各类静态资源，包括HTML文本文件及图片等二进制文件。

需注意，观察输入的URL，某些情况下路径可能仅为根目录"/" ，而非具体路径。URL本应用于定位特定静态资源，但与"./wwwroot" 拼接后，其含义变为wwwroot目录下的所有内容。显然，我们无法将整个目录内容返回给客户端。因此，当URL为根目录时，实际表示获取站点首页。

一个站点由众多资源构成。访问站点时，首先获取的是首页资源，其中包含链接以跳转至其他页面。首页本质上是一个网页，服务器已在特定路径下保存对应的HTML文档。按照惯例，首页HTML文档的文件名通常为"index" ，并存放于wwwroot目录下。客户端访问首页时，既可显式指定路径（如"/index.html" ），也可省略URL，浏览器会默认访问首页并自动将URL设为"/"。例如，在地址栏输入www.baidu.com 与www.baidu.com/index.html 效果相同。若未显式指定协议或端口，浏览器默认采用HTTPS协议及443端口。

在先前反序列化过程中，我们已提取请求行中的各个参数。因此，此处首先需判断URL是否为根目录或首页文件。若是，则直接在path 后拼接字符串"/index.html" 。由于响应报文将携带响应正文，必须在响应头中设置Content-Type 字段，以告知客户端响应正文的数据类型，确保正确解析。每种文件类型均有对应的MIME类型映射，HTML的MIME类型为"text/html"。

std::string Http_Get_Handler(Http_Request& hr)
{
    std::string file_path;
    std::string content_type;
    std::string res;
    if (hr.url == "/" || hr.url == "/index.html")
    {
        file_path = path + "/index.html";
        content_type = "text/html";
    }
    // ...
}

若非上述情况，则表明URL是一个具体路径。此时，我们直接将URL拼接到path对象上。由于该路径用于定位特定文件，其终点应为一个具体文件名，格式通常为"文件名.扩展名"，其中扩展名指示文件类型。为正确设置
Content-Type 字段，需获取文件扩展名。此处调用rfind 函数从后向前查找"."字符，若找到则返回其索引；若未找到（即返回npos ），则说明该路径可能为虚拟路径，用于路由至预定义函数。在本Web服务器的设计中，GET请求仅处理获取静态资源的情况。尽管GET请求也可用于提交表单（此时URL可能携带查询参数），但再本web服务器中暂不处理这种情况。

若rfind 返回npos，在此场景下，表示客户端请求的URL为虚拟路径，服务器将返回错误页面，指示请求的资源不存在。因此，将Content-Type 设置为text/html 。

若找到"." 符，则使用substr 函数分割出子串，即文件扩展名。我定义了一个专用函数，用于将文件扩展名映射为对应的MIME类型。在Task 类中，维护了一个静态哈希表，键和值均为字符串类型，键为文件扩展名，值为MIME类型。由于Http_Get_Handler 为类外定义的函数，为访问类内成员变量，需在Task 类中定义静态成员函数suffix_handler 。静态成员函数仅能访问静态成员变量，因此该哈希表也需声明为静态成员变量，并在类外进行初始化，插入文件扩展名与MIME类型的键值对。

std::string Http_Get_Handler(Http_Request& hr)
{
    std::string file_path;
    std::string content_type;
    std::string res;
    if (hr.url == "/" || hr.url == "/index.html")
    {
        file_path = path + "/index.html";
        content_type = "text/html";
    }
    else
    {
        file_path = path + hr.url;
        size_t pos = file_path.rfind(".");
        if (pos == std::string::npos)
        {
            content_type = "text/html";
        }
        else
        {
            std::string suffix = file_path.substr(pos);
            content_type = Task::suffix_handler(suffix);
        }
    }
    // ...
}

Task 类的suffix_handler 函数负责查询哈希表：若存在对应扩展名的键，则返回其MIME类型；否则返回HTML类型对应的值（通常用于返回错误页面）。该函数返回字符串类型，Http_Get_Handler 调用此函数获取MIME类型并设置Content-Type 。对于具体路径，接下来需定位静态资源并读取其内容，因此我实现了read_file 函数。

read_file 函数接收文件路径，根据路径定位文件。文件读取涉及文件操作，此处使用C++的ifstream 流对象。其构造函数接受一个字符串参数，表示相对或绝对路径。若为相对路径，则基于当前工作目录进行解析，并打开文件将内容加载至内存。构造函数可接受两个参数：第一个为路径，第二个为打开模式，默认为文本模式。但此处统一以二进制模式打开，即使对于文本文件也是如此。二进制模式会忽略特殊字符（如换行符）的处理，确保完整读取所有数据；而文本模式下使用getline 等函数可能忽略某些控制字符。

为获取文件大小，需配合使用tellg 和seekg 函数。seekg 用于设置读指针位置，接受两个参数：偏移量和相对位置。标准库提供了三种相对位置：std::ios::beg （文件开头）、std::ios::end （文件结尾）和std::ios::cur （当前位置）。tellg 不接受任何参数，其返回当前读指针距文件开头的偏移量

首先调用seekg 函数将文件流对象的读指针设置到文件开头。随后调用tellg 函数（该函数不接受参数），返回当前读指针的位置。由于此时读指针已位于文件开头，返回的位置即为起始位置。接着再次调用seekg 将读指针设置到文件结尾，然后通过tellg 获取当前读指针位置，即文件结束位置。

需要注意的是，tellg 的返回值类型为std::streampos 。这是一个类类型，封装了文件状态和偏移量信息，但在实际使用中可将其视为类似size_t 的偏移量表示。计算文件大小时，需要从结束位置减去起始位置，这涉及到算术运算。std::streampos 重载了减法运算符，其返回类型为std::streamoff ，这是一个有符号整数类型，在标准库的实现中，std::streamoff 通常定义为long long 类型别名。

istream& read (char* s, streamsize n);

获取文件大小后，调用ifstream 的read 函数，该函数接收一个char 类型缓冲区及文件大小参数，以二进制方式读取文件内容至缓冲区。此处，我使用string 对象content 作为缓冲区，在读取前通过resize 预分配足够空间，然后传递给read 函数。最后调用close 关闭文件并返回content 。

std::string read_file(std::string file_path)
{
    std::ifstream file(file_path, std::ios::binary);
    if (!file.is_open())
    {
        lg.logmessage(info, "file not found: %s", file_path.c_str());
        return "";
    }
    file.seekg(0, std::ios::beg);
    std::streampos start = file.tellg();
    file.seekg(0, std::ios::end);
    std::streampos end = file.tellg();
    std::streamoff file_size = end - start;
    std::string content;
    content.resize(static_cast<size_t>(file_size));
    file.seekg(0, std::ios::beg);
    file.read(&content[0], file_size);
    file.close();
    return content;
}

获取到文件内容后，接下来是构建响应报文。此时可能有读者会想：之前对于请求报文，我们会进行反序列化，用Http_request 对象来描述并保存解析得到的各个字段；那么对于响应报文，我们是否也需要定义一个类似的Http_reponse 对象来存储其各个字段呢？

这里我先说明：可以，但没必要。定义Http_request 对象的主要目的是为了更快速、更方便地访问请求报文的各个字段，比如请求行中的请求方法以及请求头的相关字段等。而对于响应报文，在当前服务端的上下文中，我们并没有访问其字段的需求——服务端只负责生成响应，并不需要解析或使用它。相反，客户端的行为与服务端是对称的，客户端可能需要解析响应报文，因此客户端才有必要定义一个Http_reponse 对象来存储响应报文的各个字段。由于服务端仅生成响应而不处理响应，所以在这里定义Http_reponse 对象并无必要。

因此，接下来我们直接构建响应报文即可。首先检查read_file 函数的返回值，即返回的string 对象是否为空。如果为空，说明read_file 打开文件失败，意味着路径无效或资源不存在。此时，响应报文的状态码应为 404，状态描述为“Not Found”。在资源未找到的情况下，我们应当向用户返回一个错误页面来提供提示。

为此，我们应在wwwroot 目录下准备一个对应的错误页面 HTML 文件。这里我在该目录下创建了一个404.html 文件。在拼接出该文件的完整路径后，再次调用read_file 读取其内容，并将其作为响应正文。获取 404 页面的内容后，依次构建响应行与响应头。响应头中必须包含描述响应正文的字段：Content-Type 用于告知客户端正文的 MIME 类型，确保正确解析；Content-Length 用于指示消息边界。此外，由于当前使用 HTTP/1.0 并采用短连接，还需添加Connection 字段，并将其值设为close 。

std::string body = read_file(file_path);
std::string header_line;
std::string header;
if (body.empty())
{
    header_line = "HTTP/1.0 404 Not Found
";
    header += "Connection: close
";
    std::string content = read_file(path + "/404.html");
    header += "Content-Length: " + std::to_string(content.size()) + "
";
    header += "Content-Type: text/html
";
    header += "
";
    res = header_line + header + content;
}

若string 对象不为空，说明成功获取到资源，此时构建的响应报文状态码为 200，状态描述为“OK”。响应头字段与之前相同，包含 Content_Length 、Content_Type 和 Connection ，最后再拼接响应正文。完成响应报文的构建后，将最终得到的string 对象返回。

std::string Http_Get_Handler(Http_Request& hr)
{
    std::string file_path;
    std::string content_type;
    std::string res;
    if (hr.url == "/" || hr.url == "/index.html")
    {
        file_path = path + "/index.html";
        content_type = "text/html";
    }
    else
    {
        file_path = path + hr.url;
        ssize_t pos = file_path.rfind(".");
        if (pos == std::string::npos)
        {
            content_type = "text/html";
        }
        else
        {
            std::string suffix = file_path.substr(pos);
            content_type = Task::suffix_handler(suffix);
        }
    }
    std::string body = read_file(file_path);
    std::string header_line;
    std::string header;
    if (body.empty())
    {
        header_line = "HTTP/1.0 404 Not Found
";
        header += "Connection: close
";
        std::string content = read_file(path + "/404.html");
        header += "Content-Length: " + std::to_string(content.size()) + "
";
        header += "Content-Type: text/html
";
        header += "
";
        res = header_line + header + content;
    }
    else
    {
        header_line = "HTTP/1.0 200 OK
";
        header += "Content-Length: " + std::to_string(body.size()) + "
";
        header += "Connection: close
";
        header += "Content-Type: " + content_type + "
";
        header += "
";
        res = header_line + header + body;
    }
    return res;
}

上文介绍了Http_Get_handler ，接下来介绍Http_Post_handler 。我们知道 POST 请求会携带请求正文，并且其请求行中的 URL 是一个虚拟路径，用于映射到服务器预定义的函数，进而调用该函数处理参数并返回结果。因此，在设计时，我们将 Web 服务器提供的服务设定为一个计算器。站点首页会提供输入框，用于接收两个操作数和一个操作符，并通过表单上传至服务器。表单内容存放在请求正文中，以键值对格式存储。

该函数的逻辑是：首先解析请求正文。由于我们知道正文格式是以 “&” 分隔的键值对，且每个键值对的顺序是不确定的（第一个不一定是操作符，也可能是操作数），但每个键的名称与 HTML 文档中对应输入项的name 属性一致：

<form action="/calc" method="POST">
    <input type="number" name="a" placeholder="输入数字 a" required>
    <br>
    <select name="op">
        <option value="+">+option>
        <option value="-">-option>
        <option value="*">*option>
        <option value="/">/option>
    select>
    <br>
    <input type="number" name="b" placeholder="输入数字 b" required>
    <br><br>
    <button type="submit">开始计算button>
form>

表单提交的目标虚拟路径是/calc 。客户端识别该路径后，即可确定调用对应的处理函数。为此，我们需要准备一个键和值均为string 类型的哈希表，其中键为每个表单数据的名称。

接下来解析请求正文：先调用find 函数查找第一个 "&" 以分割键值对。如果find 返回npos ，说明客户端构建的请求报文有误，此时应返回状态码 400（Bad Request）的响应报文。我们专门定义了process_bad_request 函数来生成此类响应，其返回类型为string 。

std::string process_bad_request()
{
    lg.logmessage(Fatal, "bad request body");
    std::string headler_line = "HTTP/1.0 400 Bad Request
";
    std::string header = "Connection: close
";
    std::string content = "Bad Request";
    header += "Content-Length: " + std::to_string(content.size()) + "
";
    header += "Content-Type: text/plain
";
    header += "
";
    return headler_line + header + content;
}

若未返回npos ，则调用substr 分割出第一个键值对。每个键值对的格式为“键=值”，因此再次调用find 在子串中查找 “=”。若未找到，同样调用process_bad_request 并返回。找到后，继续用substr 分离键和值。若值前存在前导空格也无需担心，因为stoi 会自动忽略它们。将键和值插入哈希表后，重复上述过程直至解析完毕。

std::string Http_Post_Handler(Http_Request& hr) {
    std::string res;
    std::unordered_map<std::string, std::string> val;
    size_t start = 0;
    if (hr.url == "/calc") {
        std::string body = hr.text;
        size_t pos1 = body.find("&");
        if (pos1 == std::string::npos) {
            return process_bad_request();
        }
        std::string expression = body.substr(start, pos1);
        size_t pos2 = expression.find("=");
        if (pos2 == std::string::npos) {
            return process_bad_request();
        }
        std::string result_key_str = expression.substr(start, pos2);
        std::string result_value_str = expression.substr(pos2 + 1);
        val[result_key_str] = result_value_str;
        start = pos1 + 1;
        pos1 = body.find("&", start);
        if (pos1 == std::string::npos) {
            return process_bad_request();
        }
        pos2 = body.find("=", start);
        if (pos2 == std::string::npos || pos2 > pos1) {
            return process_bad_request();
        }
        result_key_str = body.substr(start, pos2 - start);
        result_value_str = body.substr(pos2 + 1, pos1 - pos2 - 1);
        val[result_key_str] = result_value_str;
        start = pos1 + 1;
        pos2 = body.find("=", start);
        if (pos2 == std::string::npos) {
            return process_bad_request();
        }
        result_key_str = body.substr(start, pos2 - start);
        result_value_str = body.substr(pos2 + 1);
        val[result_key_str] = result_value_str;
        int calc_result;
        //...
    }

哈希表初始化完成后，计算逻辑由专门的process_calculation 函数处理，该函数即为虚拟路径映射的目标函数。其内容为：先从哈希表中获取值，调用stoi 将操作数转换为整型。由于键或值可能包含特殊字符（如空格会被编码为"+" ，"/" 等符号也会进行 URL 编码，即转换为% 后跟两个十六进制数字），因此操作符需要先解码为原始字符。解码完成后，进入switch-case 语句执行计算，并将结果存入输出型参数。

bool process_calculation(std::unordered_map<std::string, std::string>& val, int& result)
{
    int a = std::stoi(val["a"]);
    int b = std::stoi(val["b"]);
    std::string op = val["op"];
    if (op == "+" || op == "%2B" || op == "%2b") {
        op = "+";
    } else if (op == "-" || op == "%2D" || op == "%2d") {
        op = "-";
    } else if (op == "*" || op == "%2A" || op == "%2a") {
        op = "*";
    } else if (op == "/" || op == "%2F" || op == "%2f") {
        op = "/";
    } else {
        lg.logmessage(Fatal, "unsupported operator: %s", op.c_str());
        return false;
    }
    switch (op[0]) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            if (b == 0) {
                lg.logmessage(warning, "division by zero");
                return false;
            }
            result = a / b;
    }
    return true;
}

若计算成功，函数返回true；否则返回false ，并调用process_bad_request 返回错误响应。计算成功后，构建状态码为 200 的响应报文，并将硬编码的成功页面 HTML 文本作为响应正文返回。

由于本 Web 服务器仅提供计算服务，若 URL 不是/calc ，则视为无效路径，同样调用process_cad_request 并返回。

std::string Http_Post_Handler(Http_Request& hr) {
    std::string res;
    std::unordered_map<std::string, std::string> val;
    size_t start = 0;
    if (hr.url == "/calc") {
        std::string body = hr.text;
        size_t pos1 = body.find("&");
        if (pos1 == std::string::npos) {
            return process_bad_request();
        }
        std::string expression = body.substr(start, pos1);
        size_t pos2 = expression.find("=");
        if (pos2 == std::string::npos) {
            return process_bad_request();
        }
        std::string result_key_str = expression.substr(start, pos2);
        std::string result_value_str = expression.substr(pos2 + 1);
        val[result_key_str] = result_value_str;
        start = pos1 + 1;
        pos1 = body.find("&", start);
        if (pos1 == std::string::npos) {
            return process_bad_request();
        }
        pos2 = body.find("=", start);
        if (pos2 == std::string::npos || pos2 > pos1) {
            return process_bad_request();
        }
        result_key_str = body.substr(start, pos2 - start);
        result_value_str = body.substr(pos2 + 1, pos1 - pos2 - 1);
        val[result_key_str] = result_value_str;
        start = pos1 + 1;
        pos2 = body.find("=", start);
        if (pos2 == std::string::npos) {
            return process_bad_request();
        }
        result_key_str = body.substr(start, pos2 - start);
        result_value_str = body.substr(pos2 + 1);
        val[result_key_str] = result_value_str;
        int calc_result;
        if (process_calculation(val, calc_result) == false) {
            return process_bad_request();
        }
        std::string headler_line = "HTTP/1.0 200 OK
";
        std::string header = "Connection: close
";
        header += "Content-Type: text/html
";
        std::string content = "";
        content += "
计算结果展示
";
        content += "
结果为: " + std::to_string(calc_result) + "
";
        content += "返回首页";
        content += "";
        header += "Content-Length: " + std::to_string(content.size()) + "
";
        header += "
";
        res = headler_line + header + content;
        return res;
    } else {
        lg.logmessage(Fatal, "unsupported post url: %s", hr.url.c_str());
        return process_bad_request();
    }
}

至此，两个核心请求处理函数已介绍完毕。接下来只需将这两个函数返回的响应正文通过send
接口发送出去，并检查其返回值。若返回值小于 0，则记录错误日志、关闭套接字并退出；若发送成功，则关闭套接字并正常退出。

httpserver.cpp:

最后一部分是服务器主函数的实现。该服务器运行于Linux环境，通常通过命令行启动进程，配置信息可通过命令行参数传递。由于IP地址已默认设为"0.0.0.0" ，此处仅需指定端口号。命令行本质上是一个字符串，由bash进程接收，解析出命令名和参数，保存到字符串数组中，并传递给目标进程。

因此，主函数首先检查参数个数：包括命令名及其参数，应为2。若非2，则打印错误信息并退出程序。接着从字符串数组中获取端口号参数，转换为整型，随后创建Httpserver 对象，依次调用其init 和start 函数。

#include"Httpserver.hpp"
#include"log.hpp"
#include
extern log lg;
void usage(std::string progmaname)
{
        std::cout << "usage wrong: " << progmaname << " " << std::endl;
}
int main(int argc, char* argv[])
{
        if (argc != 2)
        {
                usage(argv[0]);
                exit(-1);
        }
        uint16_t port = std::stoi(argv[1]);
        Httpserver hs(_default,port);
        hs.init();
        hs.start();
        return 0;
}

源码

Httpserver.hpp:

#pragma once
#include"Socket.hpp"
#include"log.hpp"
#include"Threadpool.h"
#include
#include
#include
#include
#include
std::string _default = "0.0.0.0";
extern log lg;
class Httpserver
{
public:
        Httpserver(std::string _ip = _default, uint16_t _port=80)
                :ip(_ip)
                , port(_port)
                ,islistening(false)
        {

        }
/**
 * 初始化函数
 * 用于创建并绑定监听套接字
 */
        void init()
        {
        // 创建套接字
                listen_socket.socket();
        // 绑定IP地址和端口号
                listen_socket.bind(ip, port);
        }
/**
 * 启动服务器监听功能
 * 该函数用于启动服务器，开始接受客户端连接
 */
        void start()
        {
    // 开始监听端口
                listen_socket.listen();
    // 检查服务器是否已经在监听状态
                if (islistening)
                {
        // 如果已经在监听，记录警告日志并返回
            lg.logmessage(warning,"server is already listening");
                        return;
                }
    // 设置监听状态为true
                islistening = true;
    // 获取线程池单例并启动线程池
                threadpool& tp = threadpool::getinstance();
                tp.start();
    // 定义客户端地址结构体
 struct sockaddr_in client;
    // 设置地址结构体大小
                socklen_t client_len = sizeof(client);
    // 清零客户端地址结构体
                memset(&client, 0, client_len);
                while (islistening)
                {
                        size_t client_fd=listen_socket.accept(&client,&client_len);
                        Task t(client_fd);
                        tp.push(t);
                }
        }
private:
        uint16_t port;
        std::string ip;
        sock listen_socket;
        bool islistening;
};

Socket.hpp:

#include
#include
#include
#include
#include
#include
#include"log.hpp"
extern log lg;
enum
{   
    Socket_Error = 1,
    Bind_Error,
    Listen_Error,
    Accept_Error,
    Connect_Error,
    Usage_Error,
};

class sock
{
public:
    sock()
        :socketfd(-1)
    {

    }
    ~sock()
    {
        if (socketfd >= 0)
        {
            ::close(socketfd);
        }
    }
/**
 * 创建并配置socket
 * 该函数用于创建一个TCP套接字，并设置地址和端口重用选项
 */
    void socket()
    {
    // 使用系统调用socket创建TCP套接字
    // AF_INET表示使用IPv4地址
    // SOCK_STREAM表示使用TCP协议
    // 0表示自动选择合适的协议
        socketfd = ::socket(AF_INET, SOCK_STREAM, 0);
    // 检查socket创建是否成功
        if (socketfd < 0)
{
        // 如果创建失败，记录错误日志并退出程序
            lg.logmessage(Fatal, "socket error");
            socketfd = -1;
            exit(Socket_Error);
        }
    // 设置socket选项，允许地址和端口重用
    // opt为1，表示启用SO_REUSEADDR和SO_REUSEPORT选项
    // 这样可以避免在服务器重启时出现地址已被占用的错误
       int opt = 1;
    setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
    // 记录socket创建成功的日志
        lg.logmessage(info, "socket successfully");
    }

/**
 *  绑定IP地址和端口号到套接字
 *  ip 要绑定的IP地址，字符串形式
 *  port 要绑定的端口号，16位无符号整数
 */
    void bind(std::string ip, uint16_t port)
    {
    // 检查套接字是否有效
        if (socketfd < 0)  // 如果套接字描述符无效（小于0）
        {
            lg.logmessage(Fatal, "socket not created");  // 记录致命错误：套接字未创建
            exit(Socket_Error);  // 退出程序，套接字错误码
        }

    // 创建并清空服务器地址结构体
        struct sockaddr_in server;  // 定义IPv4地址结构体
        memset(&server, 0, sizeof(server));  // 将server结构体清零，确保所有字段初始化为0

    // 设置地址族为IPv4
        server.sin_family = AF_INET;  // 设置地址族为IPv4
    // 将端口号从主机字节序转换为网络字节序
        server.sin_port = htons(port);  // 使用htons函数将端口号转换为网络字节序

    // 处理IP地址
        if (ip == "0.0.0.0")  // 检查是否为通配地址
        {
        // 如果IP是0.0.0.0，绑定到所有可用的网络接口
            server.sin_addr.s_addr = INADDR_ANY;  // 绑定到所有可用的网络接口
        }
        else if (inet_pton(AF_INET, ip.c_str(), &server.sin_addr) <= 0)  // 尝试将IP字符串转换为网络地址格式
        {
        // 尝试将IP字符串转换为网络地址格式，如果失败则记录错误
            lg.logmessage(Fatal, "inet_pton fail");  // 记录致命错误：IP地址转换失败
            ::close(socketfd);  // 关闭套接字
            socketfd = -1;  // 将套接字描述符设置为无效值
            exit(Bind_Error);  // 退出程序，绑定错误码
        }
        socklen_t serverlen = sizeof(server);  // 获取服务器地址结构体的大小
        int n = ::bind(socketfd, (struct sockaddr*)&server, serverlen);  // 调用bind函数绑定地址
 if (n < 0)  // 检查bind函数是否执行成功
        {
            lg.logmessage(Fatal, "bind error");  // 记录致命错误：绑定失败
            ::close(socketfd);  // 关闭套接字
            socketfd = -1;  // 将套接字描述符设置为无效值
            exit(Bind_Error);  // 退出程序，绑定错误码

        }
        lg.logmessage(info, "bind successfully");  // 记录信息：绑定成功
    }
/**
 * 监听函数，用于开始监听客户端连接请求
 * 该函数首先检查socket是否已创建，然后调用listen函数开始监听
 * 如果监听失败，会进行错误处理并退出程序
 */
    void listen()
    {
    // 检查socket是否已创建，如果socketfd小于0表示socket未创建
        if (socketfd < 0)
        {
        // 记录致命错误日志：socket未创建
            lg.logmessage(Fatal, "socket not created");
        // 退出程序，退出码为Socket_Error
            exit(Socket_Error);
        }
    // 调用系统listen函数开始监听，第二个参数5表示最大连接队列长度
        int n = ::listen(socketfd, 5);
    // 检查listen函数是否成功执行
        if (n < 0)
        {
        // 记录致命错误日志：监听失败
            lg.logmessage(Fatal, "listen error");
        // 关闭socket文件描述符
            ::close(socketfd);
        // 将socketfd重置为-1，表示socket未创建
            socketfd = -1;
        // 退出程序，退出码为Listen_Error
            exit(Listen_Error);
        }
    // 记录信息日志：监听成功
        lg.logmessage(info, "listen successfully");
    }
    
	/** 接受一个客户端的连接请求*/
int accept(struct sockaddr_in* client, socklen_t* clientlen)
{
    // 检查监听套接字 socketfd 是否有效
    // 如果无效，说明服务器套接字未被正确初始化，这是一个致命错误
    if (socketfd < 0)
    {
        // 记录一条致命级别的日志信息
        lg.logmessage(Fatal, "socket not created");
        // 终止程序，并返回一个特定的错误码 Socket_Error
        exit(Socket_Error);
    }

    // 调用系统提供的 accept 函数，阻塞等待客户端连接
    // socketfd: 监听套接字描述符
    // (struct sockaddr*)client: 将客户端地址信息存入 client 指向的结构体
    // clientlen: 传入 client 结构体的大小，并接收实际地址结构的大小
    int client_fd = ::accept(socketfd, (struct sockaddr*)client, clientlen);

    // 检查 accept 是否成功
    if (client_fd < 0)
    {
        // 如果 accept 失败，记录一条致命错误日志
        lg.logmessage(Fatal, "accept error");
        // 返回 -1 表示接受连接失败
        return -1;
    }

    // 如果 accept 成功，记录一条信息日志
    lg.logmessage(info, "accept successfully");

    // 返回新创建的、用于与该客户端通信的套接字描述符
    return client_fd;
}

/**
 * 连接到服务器的函数
 */
    void connect(struct sockaddr_in* server, socklen_t serverlen)
    {
    // 检查socket是否已创建
        if (socketfd < 0)
        {
        // 记录socket未创建的致命错误日志
            lg.logmessage(Fatal, "socket not created");
        // 退出程序，错误码为Socket_Error
            exit(Socket_Error);
        }
    // 尝试连接到服务器
        int n = ::connect(socketfd, (struct sockaddr*)server, serverlen);
    // 检查连接是否成功
        if (n < 0)
        {
        // 记录连接失败的致命错误日志
            lg.logmessage(Fatal, "connect error");
        // 关闭socket
            ::close(socketfd);
        // 重置socket文件描述符
            socketfd = -1;
        // 退出程序，错误码为Connect_Error
            exit(Connect_Error);
        }
    // 记录连接成功的信息日志
        lg.logmessage(info, "connect successfully");
    }
    void close()
    {
        if (socketfd >= 0)
 {
            ::close(socketfd);
            socketfd = -1;
        }
    }
    sock(const sock&) = delete;
    sock& operator=(const sock&) = delete;
private:
    int socketfd;
};

Threadpool.h:

#pragma once
#include
#include
#include
#include
#include
#include"Task.hpp"
#define max_size 10

class threadpool
{
public:

    static threadpool& getinstance()
    {

        static threadpool instance;
        return instance;
    }

/**
 * 启动函数，用于创建多个线程执行任务
 * 该函数会创建Max_size个线程，每个线程都执行handlertask函数
 */
    void start()
    {

    // 循环创建Max_size个线程
        for (int i = 0; i < Max_size; i++)
        {

        // 声明线程标识符tid
            pthread_t tid;
        // 创建线程，执行handlertask函数，并将当前对象指针作为参数传递
        // 第一个参数：线程标识符指针
        // 第二个参数：线程属性，设为NULL表示使用默认属性
        // 第三个参数：线程处理函数，即handlertask
        // 第四个参数：传递给线程处理函数的参数，这里传递当前对象的this指针
            pthread_create(&tid, NULL, handlertask, this);
        }
    }


/**
 * 从队列中弹出一个任务
 */
    Task pop()
    {  // 从队列中弹出任务的函数
        sem_wait(&element);  // 等待有元素可用，信号量element减1
        pthread_mutex_lock(&mutex);  // 加锁，确保线程安全
        Task data = q[c_index];  // 获取当前索引处的任务
    c_index = (c_index + 1) % Max_task_size;  // 更新消费者索引，实现循环队列
        pthread_mutex_unlock(&mutex);  // 解锁
        sem_post(&space);  // 释放空间，信号量space加1
        return data;  // 返回获取的任务
    }
    // 向任务队列中添加一个任务
    void push(const Task& T)
    {
        sem_wait(&space);  // 等待空间信号量，表示队列中有空闲位置
        q[p_index] = T;    // 将任务T存入队列的当前位置
        p_index = (p_index + 1) % Max_task_size;  // 更新写入位置，使用模运算实现循环队列
        sem_post(&element);  // 发送元素信号量，表示队列中新增了一个元素
    }

    ~threadpool()
    {
        pthread_mutex_destroy(&mutex);
        sem_destroy(&element);
        sem_destroy(&space);
    }
    threadpool(const threadpool&) = delete;
    threadpool& operator=(const threadpool&) = delete;
private:
/**
 * 线程池的构造函数，用于初始化线程池
 */
    threadpool(int max_num = max_size, int max_task_size = max_size)
        :Max_size(max_num)        // 初始化最大线程数
        , c_index(0)             // 初始化消费者索引，用于任务队列的环形缓冲区
        , p_index(0)             // 初始化生产者索引，用于任务队列的环形缓冲区
        , Max_task_size(max_task_size) // 初始化任务队列的最大容量
    {
        q.resize(Max_task_size); // 调整任务队列的大小为最大容量
    // 初始化互斥锁，用于保护共享资源的访问
        pthread_mutex_init(&mutex, NULL);
    // 初始化信号量element，表示队列中的任务数量，初始为0
        sem_init(&element, 0, 0);
    // 初始化信号量space，表示队列中的可用空间，初始为Max_task_size
        sem_init(&space, 0, Max_task_size);
    }

/**
 * 线程池中工作线程的任务处理函数
 */
    static void* handlertask(void* args)
    {
    // 将传入的参数转换为线程池对象指针
       threadpool* tp = (threadpool*)args;

    // 无限循环，持续从任务队列中获取并执行任务
        while (1)
        {


        // 从线程池的任务队列中弹出一个任务
            Task task = tp->pop();
        // 执行获取到的任务
            task.run();
        }

    // 理论上不会执行到这里，因为while(1)是无限循环
        return NULL;
    }

    std::vector<Task> q;
    int Max_size;
    pthread_mutex_t mutex;
    int Max_task_size;
    int c_index;
    int p_index;
    sem_t element;
    sem_t space;
};

Task.hpp:

#pragma once
#include
#include
#include
#include
#include
#include
#include"protocol.hpp"
#include"log.hpp"
#define BUFFER_SIZE 1024
extern log lg;
std::string path="./wwwroot";
/**
 *  从指定的套接字接收完整的HTTP请求，并将其解析到Http_Request对象中
 *
 *            如果成功接收并解析了HTTP请求头（无论是否有正文），返回 true。
 *              如果在接收数据时发生错误（如recv失败），返回 false。
 * 
 * 此函数处理了两种情况：
 *       1. 没有正文的请求（如GET请求）。
 *       2. 有正文的请求（如POST请求），它会根据`Content-Length`头确保接收完整的正文。
 *       函数会阻塞，直到接收到完整的HTTP头（以"

"为标志）和完整的正文（如果存在）。
 */
bool Get_HttpRequest(size_t socketfd, Http_Request& hr)
{
    // 用于存储从套接字接收到的所有原始HTTP请求数据
    std::string data;
    // 临时缓冲区，用于每次recv调用
    char buffer[BUFFER_SIZE];

    // --- 第一阶段：循环接收数据，直到收到完整的HTTP请求头 ---
    // HTTP请求头以 "

" 结尾，这是一个明确的分界符
    while (true)
    {
        // 从套接字读取数据，最多读取 BUFFER_SIZE-1 字节，为 '' 预留一个位置
        ssize_t read_bytes = recv(socketfd, buffer, BUFFER_SIZE - 1, 0);

        // recv 的返回值 <= 0 表示错误或连接被对端关闭
        if (read_bytes <= 0)
        {
            // 记录一条致命错误日志
            lg.logmessage(Fatal, "recv error");
            // 接收失败，返回 false
            return false;
        }

        // 将本次读取到的数据追加到总数据字符串 data 中
        data.append(buffer, read_bytes);

        // 检查 data 中是否已包含完整的HTTP请求头结束符
        if (data.find("

") != std::string::npos)
        {
            // 找到了，说明请求头已完整，跳出循环
            break;
        }
    }

    // 从完整的数据中提取出HTTP请求头部分（包括结束符"

"）
    std::string head = data.substr(0, data.find("

") + 4);

    // --- 第二阶段：检查是否有请求正文，并处理 ---
    // 在请求头中查找 "Content-Length:" 字段，这是判断是否有正文以及正文长度的关键
    size_t pos = data.find("Content-Length:");
    if (pos != std::string::npos)
    {
        // 找到了 Content-Length 字段，说明这是一个带有正文的请求（通常是POST）
        
        // 1. 解析 Content-Length 的值
        // 找到该字段所在行的行尾
        ssize_t endpos = head.find("
", pos);
        // 提取 "Content-Length:" 后面的数字字符串
        std::string content_length_str = head.substr(pos + 15, endpos - pos - 15); // "Content-Length:" 长度为15
        // 将字符串转换为整数，得到正文的期望长度
        size_t content_length = std::stoi(content_length_str);

        // 2. 检查当前已接收的数据中是否包含了完整的正文
        // 计算当前已接收的正文部分的长度
        size_t remaining = data.size() - head.size();

        if (remaining < content_length)
        {
            // 情况A：正文不完整，需要继续从套接字读取剩余的正文数据
            
            // 提取已接收的部分正文
            std::string body = data.substr(data.find("

") + 4, remaining);
            // 计算还需要读取的字节数
            int to_read = content_length - remaining;
            char body_buffer[BUFFER_SIZE];

            // 循环读取，直到读完所有剩余的正文数据
            while (to_read > 0)
            {
                // 计算本次最多能读取多少字节（防止读取超过需求）
                ssize_t bytes_to_recv = std::min(BUFFER_SIZE - 1, to_read);
                ssize_t read_bytes = recv(socketfd, body_buffer, bytes_to_recv, 0);

                if (read_bytes <= 0)
                {
                    lg.logmessage(Fatal, "recv error");
                    return false;
                }

                // 将新读取的数据追加到正文字符串中
                body.append(body_buffer, read_bytes);
                // 更新还需要读取的字节数
                to_read -= read_bytes;
            }
            // 将完整的正文存入 hr 对象
            hr.text = body;
        }
        else
        {
            // 情况B：正文已经完整地包含在第一次接收的数据中
            // 直接从 data 中提取指定长度的正文
            hr.text = data.substr(data.find("

") + 4, content_length);
        }
    }
    // 如果没有找到 "Content-Length"，则认为请求没有正文，hr.text 保持为空

    // --- 第三阶段：解析请求头 ---
    // 调用 Http_Request 对象的 Deserialization 方法来解析请求头字符串
    bool res = hr.Deserialization(head);

    // 调试打印：输出解析后的 Http_Request 对象的内容
    hr.debugprint();

    // 返回请求头的解析结果
    return res;
}

/**
 *  从指定路径读取文件内容
 * 
 * 返回文件内容字符串，如果文件打开失败则返回空字符串
 */
std::string read_file(std::string file_path)
{
    // 以二进制模式打开文件
       std::ifstream file(file_path,std::ios::binary);
    // 检查文件是否成功打开
       if(!file.is_open())
       {
        // 记录文件未找到的日志
        lg.logmessage(info,"file not found:%s",file_path.c_str());
        return "";
       }
    // 获取文件开始位置
       std::streampos start=file.tellg();
    // 移动文件指针到末尾
 file.seekg(0,std::ios::end);
    // 获取文件结束位置
       std::streampos end=file.tellg();
    // 计算文件大小
       size_t file_size=end-start;
    // 创建并调整字符串大小以容纳文件内容
       std::string content;
       content.resize(file_size);
    // 将文件指针移回开始位置
       file.seekg(0,std::ios::beg);
    // 读取文件内容到字符串
       file.read(&content[0],file_size);
    // 关闭文件
       file.close();
    // 返回读取的文件内容
       return content;
}

std::string Http_Get_Handler(Http_Request& hr);

/**
 * 处理错误的HTTP请求，返回400 Bad Request响应
 * 
 *  std::string 包含HTTP响应头的完整HTTP响应消息
 */
std::string process_bad_request()
{
    // 记录错误日志，级别为Fatal
            lg.logmessage(Fatal,"bad request body");
    // 构建HTTP状态行
            std::string headler_line="HTTP/1.0 400 Bad Request
";
    // 构建HTTP头部字段
            std::string header="Connection: close
";
    // 设置响应内容
            std::string content="Bad Request";
    // 添加内容长度和内容类型头部
            header+="Content-Length: "+std::to_string(content.size())+"
";
            header+="Content-Type: text/plain
";
    // 添加空行表示头部结束
            header+="
";
    // 返回完整的HTTP响应
            return headler_line+header+content;
}
/**
 *  根据输入的操作数和运算符执行基本的算术计算
 * 
 *  如果计算成功执行，返回 true。
 *  如果遇到不支持的运算符或除零错误，返回 false。
 * 
 * 此函数会处理运算符的URL编码形式，例如 "%2B" 会被解码为 "+"。
 *  它会检查除零错误，但不会检查其他潜在的整数溢出问题。
 */
bool process_calculation(std::unordered_map<std::string, std::string>& val, int& result)
{
    // 从映射中提取操作数 "a" 和 "b"，并将它们从字符串转换为整数
    int a = std::stoi(val["a"]);
    int b = std::stoi(val["b"]);

    // 从映射中提取运算符 "op"
    std::string op = val["op"];

    // --- 运算符规范化 ---
    // 将URL编码的运算符或不同大小写的表示统一为标准的单字符运算符
    if (op == "+" || op == "%2B" || op == "%2b") // 检查加号
    {
        op = "+";
    }
    else if (op == "-" || op == "%2D" || op == "%2d") // 检查减号
    {
        op = "-";
    }
    else if (op == "*" || op == "%2A" || op == "%2a") // 检查乘号
    {
        op = "*";
    }
    else if (op == "/" || op == "%2F" || op == "%2f") // 检查除号
    {
        op = "/";
    }
    else
    {
        // 如果运算符不是以上任何一种，则记录一条致命错误日志并返回失败
        lg.logmessage(Fatal, "unsupported operator:%s", op.c_str());
        return false;
    }

    // --- 执行计算 ---
    // 使用 switch 语句根据规范化后的运算符执行相应的计算
    switch (op[0]) // 使用 op[0] 进行比较，因为此时 op 已是单字符
    {
        case '+': // 加法
            result = a + b;
            break;
        case '-': // 减法
            result = a - b;
            break;
        case '*': // 乘法
            result = a * b;
            break;
        case '/': // 除法
            // 安全检查：防止除以零
            if (b == 0)
            {
                // 如果除数为0，记录一条警告日志并返回失败
                lg.logmessage(warning, "division by zero");
                return false;
            }
            // 执行整数除法
            result = a / b;
            break; // 为 switch 语句添加了缺失的 break
    }

    // 所有操作成功完成，返回 true
    return true;
}

/**
 *  处理HTTP POST请求，目前主要支持一个计算器功能
 * 
 * 此函数专门处理发往 `/calc` URL的POST请求。它期望请求体中包含三个URL编码的
 * 键值对（例如 "a=10&op=+&b=20"），分别代表第一个操作数、运算符和第二个操作数。
 * 它会解析这些参数，执行计算，并将结果嵌入到一个HTML页面中返回给客户端。
 * 对于任何其他URL或不合法的请求格式，它会返回一个400 Bad Request错误。
 * 
 *  此函数依赖于 `process_calculation` 函数来执行实际的数学运算，
 *       和 `process_bad_request` 函数来生成错误响应。
 *       请求体的解析逻辑较为硬编码，期望固定的三个键值对格式。
 */
std::string Http_Post_Handler(Http_Request& hr)
{
    // --- 1. 初始化 ---
    std::string res;  // 存储最终要返回的HTTP响应字符串
    std::unordered_map<std::string, std::string> val;  // 用于存储从请求体解析出的键值对
    size_t start = 0;  // 辅助变量，用于在解析请求体时标记当前处理的起始位置

    // --- 2. 检查并处理特定的POST URL ---
    // 检查请求的URL路径是否为 "/calc"
    if (hr.url == "/calc")
    {
        // --- 2a. 获取并解析请求体 ---
        // 从 Http_Request 对象中获取POST请求的原始请求体
        std::string body = hr.text;

        // 手动解析请求体，期望格式为 "key1=value1&key2=value2&key3=value3"
        // 这是一个硬编码的解析过程，假设有三个键值对

        // --- 解析第一个键值对 ---
        size_t pos1 = body.find("&"); // 查找第一个键值对的结束符
        if (pos1 == std::string::npos)
        {
            // 如果没有找到，说明格式错误，返回400 Bad Request
            return process_bad_request();
        }
        std::string expression = body.substr(start, pos1); // 提取第一个键值对字符串
        size_t pos2 = expression.find("="); // 在键值对中查找 "="
        if (pos2 == std::string::npos)
        {
            // 没找到 "="，格式错误
            return process_bad_request();
        }
        // 提取键和值，并存入 map
        std::string result_key_str = expression.substr(start, pos2);
        std::string result_value_str = expression.substr(pos2 + 1);
        val[result_key_str] = result_value_str;

        // --- 解析第二个键值对 ---
        start = pos1 + 1; // 更新起始位置到第二个键值对的开头
        pos1 = body.find("&", start); // 查找第二个键值对的结束符
        if (pos1 == std::string::npos)
        {
            return process_bad_request();
        }
        pos2 = body.find("=", start); // 查找 "="
        // 检查 "=" 是否存在且在正确的范围内（在当前 "&" 之前）
        if (pos2 == std::string::npos || pos2 > pos1)
        {
            return process_bad_request();
        }
        // 提取键和值
        result_key_str = body.substr(start, pos2 - start);
        result_value_str = body.substr(pos2 + 1, pos1 - pos2 - 1);
        val[result_key_str] = result_value_str;

        // --- 解析第三个键值对 ---
        start = pos1 + 1; // 更新起始位置
        pos2 = body.find("=", start); // 查找 "="
        if (pos2 == std::string::npos)
        {
            return process_bad_request();
        }
        // 提取键和值，直到字符串末尾
        result_key_str = body.substr(start, pos2 - start);
        result_value_str = body.substr(pos2 + 1);
        val[result_key_str] = result_value_str;

        // --- 2b. 执行计算 ---
        int calc_result;
        // 调用辅助函数进行计算，传入解析出的键值对 map
        if (process_calculation(val, calc_result) == false)
        {
            // 如果计算失败（例如不支持的运算符或除零），返回错误响应
            return process_bad_request();
        }

        // --- 2c. 构建成功的HTTP响应 ---
        // 构建HTTP状态行
        std::string headler_line = "HTTP/1.0 200 OK
";
        // 构建HTTP响应头
        std::string header = "Connection: close
";
        header += "Content-Type: text/html
";

        // 动态生成HTML响应体，用于展示计算结果
        std::string content = "";
        content += "
计算结果展示
";
        content += "
结果为: " + std::to_string(calc_result) + "
";
        content += "返回首页";
        content += "";

        // 完成响应头，添加内容长度和结束符
        header += "Content-Length: " + std::to_string(content.size()) + "
";
        header += "
"; // 空行，标志HTTP头部结束

        // 拼接完整的HTTP响应
        res = headler_line + header + content;
        return res;
    }
    else
    {
        // --- 3. 处理不支持的POST URL ---
        // 如果URL不是 "/calc"，记录一条致命错误日志
        lg.logmessage(Fatal, "unsupported post url:%s", hr.url.c_str());
        // 并返回一个通用的错误响应
        return process_bad_request();
    }
}

class Task
{
public:
    Task()
 :socketfd(-1)
    {

    }
    Task(int _socketfd)
        :socketfd(_socketfd)
    {

    }
/**
 *  处理文件后缀名，返回对应的MIME类型
 * 返回对应的MIME类型字符串，如果找不到则返回默认的html类型
 */
 static std::string suffix_handler(std::string suffix)
{
    // 在map中查找对应的后缀名
    auto pos=map.find(suffix);
    // 如果找不到对应的后缀名
    if (pos == map.end())
    {
        // 返回默认的html类型
        return map[".html"];
    }
    // 返回找到的对应MIME类型
    return map[suffix];

}
/**
 * 运行HTTP请求处理函数
 * 该函数负责接收HTTP请求、根据请求类型(GET/POST)调用相应的处理函数，
 * 并将处理结果发送回客户端，最后关闭socket连接
 */
    void run()
    {
    // 创建HTTP请求对象
        Http_Request hr;
    // 获取HTTP请求
        bool get_result = Get_HttpRequest(socketfd,hr);
    // 如果获取请求失败，记录错误日志并关闭socket连接
        if (get_result == false)
        {
            lg.logmessage(Fatal,"get http request error");
            close(socketfd);
            return;
        }
        std::string res;  // 用于存储HTTP响应结果
    // 根据HTTP方法类型调用相应的处理函数
        if (hr.method == "GET")
        {
           res=Http_Get_Handler(hr);  // 处理GET请求
        }
        else if (hr.method == "POST")
        {
            res=Http_Post_Handler(hr);  // 处理POST请求
 }
        else
        {
        // 如果是不支持的HTTP方法，记录警告日志并关闭socket连接
            lg.logmessage(warning,"unsupported method:%s",hr.method.c_str());
            close(socketfd);
            return;
        }
    // 发送HTTP响应
        int send_bytes=send(socketfd,res.c_str(),res.size(),0);
    // 如果发送失败，记录错误日志并关闭socket连接
        if(send_bytes<0)
        {
            lg.logmessage(Fatal,"send error");
            close(socketfd);
            return;
        }
    // 正常处理完成后关闭socket连接
        close(socketfd);
    }
private:
    int socketfd;
    static std::unordered_map<std::string, std::string> map;
};
std::unordered_map<std::string, std::string> Task::map={
    {".html","text/html"},
    {".css","text/css"},
    {".png","image/png"},
    {".jpg","image/jpeg"}
};
/**
 * 处理HTTP GET请求并生成相应的HTTP响应
 * 
 * 该函数根据请求的URL路径，从服务器文件系统中读取对应的静态文件，
 * 构建并返回一个完整的HTTP响应字符串。它能处理首页请求，也能处理其他
 * 类型的静态资源（如CSS、JavaScript、图片等），并自动设置正确的
 * Content-Type。如果请求的文件不存在，它会返回一个404 Not Found错误页面。
 * 
 */
std::string Http_Get_Handler(Http_Request& hr)
{
    // --- 1. 初始化变量 ---
    // 定义用于构建响应的关键变量
    std::string file_path;    // 存储请求文件的完整服务器路径
    std::string content_type; // 存储文件的MIME类型（如 "text/html"）
    std::string res;         // 存储最终构建好的完整HTTP响应字符串

    // --- 2. 确定文件路径和内容类型 ---
    // 检查请求的URL是否为根目录 "/" 或首页 "/index.html"
    if (hr.url == "/" || hr.url == "/index.html")
    {
        // 如果是首页请求，则拼接出首页的完整路径
        file_path = path + "/index.html"; // 假设 `path` 是服务器根目录
        // 首页的内容类型明确为HTML
        content_type = "text/html";
    }
    else
    {
        // 如果是其他文件请求，直接将URL拼接到根目录后
        file_path = path + hr.url;

        // --- 2a. 根据文件后缀确定MIME类型 ---
        // 查找文件路径中最后一个'.'的位置，以提取文件扩展名
        ssize_t pos = file_path.rfind(".");
        if (pos == std::string::npos)
        {
            // 如果找不到后缀（如请求一个没有扩展名的文件），则默认按HTML处理
            content_type = "text/html";
        }
        else
        {
            // 提取文件后缀（包括点，如 ".html"）
            std::string suffix = file_path.substr(pos);
            // 调用辅助函数根据后缀获取正确的MIME类型
            content_type = Task::suffix_handler(suffix);
        }
    }

    // --- 3. 尝试读取请求的文件 ---
    // 调用 `read_file` 函数读取文件内容到 `body` 字符串中
    std::string body = read_file(file_path);

    // --- 4. 构建HTTP响应 ---
    // 初始化状态行和头部字段
    std::string headler_line; // HTTP响应状态行（如 "HTTP/1.0 200 OK"）
    std::string header;       // HTTP响应头部字段

    // 检查文件是否成功读取（`body` 是否为空）
    if (body.empty())
    {
        // --- 4a. 文件不存在，构建404 Not Found响应 ---
        // 设置404状态行
        headler_line = "HTTP/1.0 404 Not Found
";
        // 添加连接关闭头部，告知客户端此响应后连接将关闭
        header += "Connection: close
";
        // 读取自定义的404错误页面内容
        std::string content = read_file(path + "/404.html");
        // 添加Content-Length头部，指明响应体大小
        header += "Content-Length: " + std::to_string(content.size()) + "
";
        // 添加Content-Type头部，指明响应体是HTML
        header += "Content-Type: text/html
";
        // 头部结束标志
        header += "
";
        // 拼接完整的404响应：状态行 + 头部 + 错误页面内容
        res = headler_line + header + content;
    }
    else
    {
        // --- 4b. 文件存在，构建200 OK响应 ---
        // 设置200成功状态行
        headler_line = "HTTP/1.0 200 OK
";
        // 添加Content-Length头部
        header += "Content-Length: " + std::to_string(body.size()) + "
";
        // 添加Connection头部
        header += "Connection: close
";
        // 添加Content-Type头部，使用之前确定的MIME类型
        header += "Content-Type: " + content_type + "
";
        // 头部结束标志
        header += "
";
        // 拼接完整的成功响应：状态行 + 头部 + 文件内容
        res = headler_line + header + body;
    }

    // --- 5. 返回构建好的HTTP响应 ---
    return res;
}