基于http协议的服务器代码编写(可以访问指定路径的资源版+添加跳转网页功能 ...

目次
可以访问指定路径资源的服务端
编写
引入
介绍
代码
Serialization.hpp
404_err.html
示例
增长跳转网页功能
href
介绍 
代码 
root.html
page1.html
page2.html
示例
添加重定向功能
引入
介绍
代码
示例
添加显示图片功能
引入
介绍
代码
http_server.hpp
Serialization.hpp
root_page.html
示例 
修改为多线程版(短毗连) 
介绍
代码

---

可以访问指定路径资源的服务端

编写

   引入

  如果我们要访问客户端指定路径的资源,就得把请求拆分出来
  

• url里记录了要访问资源的路径
  
• 拆分的过程着实就是反序列化
  

    介绍

  那么题目就酿成了 -- 怎样序列化/反序列化 
  

• 因为我们只用编写服务端(因为客户端有浏览器主动帮我们进行处理惩罚),所以只涉及请求的反序列化+响应的序列化
  
• 着实响应的序列化我们早就在上一个版本里做过了,我们把它再做个处理惩罚并且拆分出来
  

  请求怎样序列化(格式化数据 -> 字符串)呢?
  

• 把响应报头放在vector<string>里
  
• 响应正文单独存放在string里
  
• 在拼接的时候,利用某个分隔符分开他们(比如http协议里规定的\r\n,固然这个分隔符只适用于报头部分)
  

  响应怎样反序列化(字符串-> 格式化数据)呢?
  

• 就是把上述过程反过来
  
• 找到分隔符,将得到的数据赋值给结构体对应的字段
  
• 详细来说就是:
  
• 以\r\n为分隔符,找出报头的每一行,将每一行push到容器里,同时删除掉源串里的内容+"/r/n"
  
• 如果读到空行(内容为空)时,就已经将报头读完了
  
• 然后探求报头里的content-length字段,找到后拿到正文长度,就可以继承把正文也拆出来了
  

  怎样得到我们的目标url呢?
  

• 也就是要继承细化
  
• url在请求行里,也就是报头的第一行=vector里的第一个元素
  
• 把它以空格为分隔符,拆出三大部分,即可得到纯净的url
  
• 我们可以手动分割
  
• 也可以利用ss流,它默认以空格为分隔符主动分割,只必要用变量给他接着就行(就像水倒出来,用杯子接着它哈哈哈)
  

  得到url后,我们必要将它和我们自定义的web根目次的位置拼接起来
  

• 也就是在上一个版本那边介绍的那样,拼接起来得到[要访问的资源在linux中的现实路径]:
  
• 
  
  

  但是这里我们要增长一个特殊处理惩罚:
  

• 当访问根目次时,必要手动让它访问我们设定的首页文件
  
• 并且当访问不存在的页面时,必要手动让它访问我们设定好的错误页面
  

  
   代码

1. #pragma once
3. #include <signal.h>
4. #include <unistd.h>
5. #include <cstring>
6. #include <functional>
8. #include "socket.hpp"
9. #include "Serialization.hpp"
11. static MY_SOCKET my_socket;
13. #define buff_size 1024 * 30
14. #define root_path "./root_page"
15. #define def_file "root.html"
17. class http_server
18. {
19. public:
20.     http_server(const uint16_t port, const std::string &ip = "0.0.0.0")
21.         : port_(port), ip_(ip) {}
22.     ~http_server() {}
23.     void run()
24.     {
25.         init();
26.         while (true)
27.         {
28.             uint16_t client_port;
29.             std::string client_ip;
30.             lg(DEBUG, "accepting ...");
31.             int sockfd = my_socket.Accept(client_ip, client_port);
32.             if (sockfd == -1)
33.             {
34.                 continue;
35.             }
36.             lg(INFO, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, client_ip.c_str(), client_port);
38.             int ret = fork();
39.             if (ret == 0)
40.             {
41.                 my_socket.Close();
42.                 char buffer[buff_size];
43.                 std::string in_buffer;
45.                 while (true)
46.                 {
47.                     memset(buffer, 0, sizeof(buffer));
48.                     int n = read(sockfd, buffer, sizeof(buffer)); //"size"\n"a op b"\n
49.                     if (n > 0)
50.                     {
51.                         buffer[n] = 0;
52.                         lg(INFO, "get request");
53.                         in_buffer += buffer; // 连续读取
54.                         lg(INFO, "%s", in_buffer.c_str());
55.                         request req;
56.                         req.deserialize(in_buffer);
58.                         // 构建访问资源的路径
59.                         std::string def_page = root_path;
60.                         if (req.url_ == "/")
61.                         {
62.                             def_page += "/";
63.                             def_page += def_file;
64.                         }
65.                         else
66.                         {
67.                             def_page += req.url_;
68.                         }
70.                         // 构建响应
71.                         response res;
72.                         res.version_ = "HTTP/1.1";
73.                         std::string text = get_page(def_page);
74.                         if (text.empty())
75.                         {
76.                              res.code_ = 404;
77.                              res.desc_ = "Not Found";
78.                              def_page = root_path;
79.                              def_page += "/";
80.                              def_page += "404_err.html";
82.                              res.text_ = get_page(def_page);
83.                               
84.                         }
85.                         else
86.                         {
87.                             res.code_ = 200;
88.                             res.desc_ = "OK";
89.                             res.text_ = text;
90.                         }
92.                         std::string cl = "Content-Length: ";
93.                         cl += std::to_string((res.text_).size());
94.                         cl += protocol_sep;
95.                         (res.title_).push_back(cl);
97.                         std::string content;
98.                         res.serialize(content);
100.                         write(sockfd, content.c_str(), content.size());
101.                     }
102.                     else if (n == 0)
103.                     {
104.                         lg(INFO, "%s quit", client_ip.c_str());
105.                         break;
106.                     }
107.                     else // 读出错误
108.                     {
109.                         break;
110.                     }
111.                 }
112.                 // lg(INFO, "fork quit");
113.                 exit(0);
114.                 close(sockfd);
115.             }
116.         }
117.     }
119. private:
120.     void init()
121.     {
122.         signal(SIGPIPE, SIG_IGN);
123.         signal(SIGCHLD, SIG_IGN);
125.         my_socket.Socket();
126.         my_socket.Bind(port_);
127.         my_socket.Listen();
128.         lg(INFO, "server init done");
129.     }
130.     std::string get_page(std::string path)
131.     {
132.         std::ifstream in(path.c_str());
133.         if (!in.is_open())
134.         {
135.             return "";
136.         }
137.         std::string content, tmp;
138.         while (std::getline(in, tmp))
139.         {
140.             content += tmp;
141.         }
142.         return content;
143.     }
145. private:
146.     uint16_t port_;
147.     std::string ip_;
148. };

复制代码

Serialization.hpp

1. #pragma once
3. #include <string>
4. #include <vector>
5. #include <sstream>
6. #include <fstream>
7. #include <iostream>
9. #define protocol_sep "\r\n"
10. #define blank_sep ' '
12. class request
13. {
14. public:
15.     request()
16.         : type_(""), url_(""), version_(""), text_("") {}
17.     bool deserialize(std::string &content)
18.     {
19.         std::string tmp;
20.         size_t left = 0;
21.         while (true)
22.         {
23.             size_t pos = content.find(protocol_sep, left);
24.             if (pos == std::string::npos)
25.             {
26.                 return false;
27.             }
29.             tmp = content.substr(left, pos - left); // 左闭右开
30.             left = pos + 2;
31.             if (tmp.empty()) // 读到空行
32.             {
33.                 break;
34.             }
35.             else
36.             {
37.                 title_.push_back(tmp);
38.             }
39.         }
41.         // 细分请求行
42.         std::string request_line = title_[0];
43.         std::stringstream ss(request_line);
44.         ss >> type_ >> url_ >> version_;
46.         // 如果有正文的话
47.         std::string comp = "Content-Length: ";
48.         bool is_find = false;
49.         int size = 0;
50.         for (auto &it : title_)
51.         {
52.             size_t pos = it.find(comp);
53.             if (pos != std::string::npos)
54.             {
55.                 ssize_t right = it.find(protocol_sep);
56.                 std::string s_size = it.substr(pos + comp.size(), right - pos - comp.size());
57.                 size = stoi(s_size);
58.                 is_find = true;
59.                 break;
60.             }
61.         }
62.         if (!is_find)
63.         { // 没有Content-Length字段
64.             content.erase(0, left + 2);
65.         }
66.         else
67.         {
68.             text_ = content.substr(left + 2, size);
69.             content.erase(0, left + 2 + size);
70.         }
71.         return true;
72.     }
74. public:
75.     std::string type_;
76.     std::string url_;
77.     std::string version_;
78.     std::vector<std::string> title_;
79.     std::string text_;
80. };
82. class response
83. {
84. public:
85.     response()
86.         : version_(""), code_(0), desc_(""), text_("") {}
87.     void serialize(std::string &content)
88.     {
89.         // 响应行
90.         std::string header = version_;
91.         header += blank_sep;
92.         header += std::to_string(code_);
93.         header += blank_sep;
94.         header += desc_;
95.         header += protocol_sep;
97.         // 响应报头
98.         std::string attribute;
99.         for (auto &it : title_)
100.         {
101.             attribute += it;
102.             attribute += protocol_sep;
103.         }
105.         content = header + attribute + protocol_sep + text_;
106.     }
108. public:
109.     std::string version_;
110.     int code_;
111.     std::string desc_;
112.     std::vector<std::string> title_;
113.     std::string text_;
114. };

复制代码

404_err.html

  这是我上网任意搜的一个(毕竟咱也不是做前端的,没必要本身写)

1. <!DOCTYPE html>
2. <html>
4. <head>
5.     <title>404-对不起！您访问的页面不存在</title>
6.     <meta charset="UTF-8" http-equiv="Content-Type" content="text/html; charset=utf-8" />
7.     <style>
8.         body {
9.             margin: 0;
10.             padding: 0;
11.             width: 100%;
12.             height: 100%;
13.             color: #0e356c;
14.             display: table;
15.             font-weight: 100;
16.             font-family: 'Lato';
17.         }
19.         .container {
20.             text-align: center;
21.             display: table-cell;
22.             vertical-align: middle
23.         }
25.         .content {
26.             text-align: center;
27.             display: inline-block;
28.         }
30.         .title {
31.             font-size: 42px;
32.             margin-bottom: 40px;
33.         }
34.     </style>
36. </head>
38. <body>
39.     <div class="container">
40.         <div class="content">
41.             <div class="title">404-对不起！您访问的页面不存在</div>
42.         </div>
43.     </div>
44. </body>
46. </html>

复制代码

  
   示例

  这是我们创建的多个html文件结构:
  

• 
  
  

  访问指定资源:
  

• 
  
  
• 
  
  

  如果访问的资源不存在:
  

• 
  
  

  
增长跳转网页功能

   href

  是 HTML 元素中常用的属性，用于指定链接的目标地址
  

• 
  
  

  跳转网页时不一定都发送了请求,因为浏览器会缓存一些网页
    介绍 

  路径可以是绝对路径,也可以是相对路径
  

• 所以可以实现跳转外部/内部网页
  

    代码 

  root.html

1. <!DOCTYPE html>
2. <html>
4. <head>
5.     <meta charset="UTF-8">
6.     <title>my title</title>
7. </head>
9. <body>
10.     <h1>hello.</h1>
11.     <h2>hello..</h2>
12.     <h3>hello...</h3>
13.     <p>hello world!</p>
14.     <h2>跳转至第一个页面</h2>
15.     <p><a href="a/page1.html">page1</a></p>
16.     <h2>跳转至第二个页面</h2>
17.     <p><a href="a/b/page2.html">page2</a></p>
19. </body>
21. </html>

复制代码

page1.html

1. <!DOCTYPE html>
2. <html>
4. <head>
5.     <meta charset="UTF-8">
6.     <title>my title</title>
7. </head>
9. <body>
10.     <h1>第一个页面</h1>
11.     <p>hello first</p>
12.     <h2>跳转至第二个页面</h2>
13.     <p><a href="b/page2.html">page2</a></p>
14.     <h2>跳转至首页</h2>
15.     <p><a href="../root.html">root</a></p>
17. </body>
19. </html>

复制代码

page2.html

1. <!DOCTYPE html>
2. <html>
4. <head>
5.     <meta charset="UTF-8">
6.     <title>my title</title>
7. </head>
9. <body>
10.     <h1>第二个页面</h1>
11.     <p>hello second</p>
12.     <h2>跳转至第一个页面</h2>
13.     <p><a href="../page1.html">page1</a></p>
14.     <h2>跳转至首页</h2>
15.     <p><a href="../../root.html">root</a></p>
17. </body>
19. </html>

复制代码

   示例

  当我们起首访问page2:
  

• 
  
  

  点击跳转首页后:
  

• 
  
  

  点击跳转page1后:
  

• 
  
  

  
添加重定向功能

   引入

  我们在上一篇博客中介绍过重定向的概念 -- 域名介绍,url的介绍+原理+特殊字符的处理惩罚,网络行为,http协议请求/响应的格式+结构,状态码介绍,临时/永世重定向,http报头常见字段,fiddler-CSDN博客
    介绍

  我们这里假定当客户端访问/302时,就触发重定向功能
  

• 也就是让响应的状态码为302
  
• 浏览器会帮我们根据http协议 -- 当状态码为302时,主动跳转到location字段定义的资源(这里我们设置为百度主页,都行的啦)
  
• 因为只是一个测试嘛,起到一个看看重定向结果的作用
  

    代码

  只必要修改动态构建响应部分即可:

1.     void run()
2.     {
3.         init();
4.         while (true)
5.         {
6.             uint16_t client_port;
7.             std::string client_ip;
8.             lg(DEBUG, "accepting ...");
9.             int sockfd = my_socket.Accept(client_ip, client_port);
10.             if (sockfd == -1)
11.             {
12.                 continue;
13.             }
14.             lg(INFO, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, client_ip.c_str(), client_port);
16.             int ret = fork();
17.             if (ret == 0)
18.             {
19.                 my_socket.Close();
20.                 char buffer[buff_size];
21.                 std::string in_buffer;
23.                 while (true)
24.                 {
25.                     memset(buffer, 0, sizeof(buffer));
26.                     int n = read(sockfd, buffer, sizeof(buffer)); //"size"\n"a op b"\n
27.                     if (n > 0)
28.                     {
29.                         bool code_302 = false;
30.                         buffer[n] = 0;
31.                         lg(INFO, "get request");
32.                         in_buffer += buffer; // 连续读取
33.                         lg(INFO, "%s", in_buffer.c_str());
34.                         request req;
35.                         req.deserialize(in_buffer);
37.                         // 构建访问资源的路径
38.                         std::string def_page = root_path;
39.                         if (req.url_ == "/")
40.                         {
41.                             def_page += "/";
42.                             def_page += def_file;
43.                         }
44.                         else if (req.url_ == "/302")
45.                         {
46.                             code_302 = true;
47.                         }
48.                         else
49.                         {
50.                             def_page += req.url_;
51.                         }
53.                         // 构建响应
54.                         response res;
55.                         res.version_ = "HTTP/1.1";
56.                         if (code_302)
57.                         {
58.                             res.code_ = 302;
59.                             res.desc_ = "Found";
61.                             std::string cl = "Location: ";
62.                             cl += "https://www.baidu.com";
63.                             cl += protocol_sep;
64.                             (res.title_).push_back(cl);
65.                         }
66.                         else
67.                         {
68.                             std::string text = get_page(def_page);
69.                             if (text.empty())
70.                             {
71.                                 res.code_ = 404;
72.                                 res.desc_ = "Not Found";
73.                                 def_page = root_path;
74.                                 def_page += "/";
75.                                 def_page += "404_err.html";
77.                                 res.text_ = get_page(def_page);
78.                             }
79.                             else
80.                             {
81.                                 res.code_ = 200;
82.                                 res.desc_ = "OK";
83.                                 res.text_ = text;
84.                             }
86.                             std::string cl = "Content-Length: ";
87.                             cl += std::to_string((res.text_).size());
88.                             cl += protocol_sep;
89.                             (res.title_).push_back(cl);
90.                         }
92.                         std::string content;
93.                         res.serialize(content);
95.                         write(sockfd, content.c_str(), content.size());
96.                     }
97.                     else if (n == 0)
98.                     {
99.                         lg(INFO, "%s quit", client_ip.c_str());
100.                         break;
101.                     }
102.                     else // 读出错误
103.                     {
104.                         break;
105.                     }
106.                 }
107.                 // lg(INFO, "fork quit");
108.                 exit(0);
109.                 close(sockfd);
110.             }
111.         }
112.     }

复制代码

   示例

  服务端收到的请求:
  

• 
  
  

   成功跳转到我们设定好的百度主页
  

• 偶然候大概会一直转圈圈,多切换下网络
  

  
添加显示图片功能

   引入

  网页一样平常都会有图片
  

• 图片也属于网络资源,也必要浏览器向服务器请求这个资源
  
• 所以图片资源也会放在web根目次下
  

  这也就意味着:
  

• 当我们请求一个页面后,浏览器不仅必要请求网页,还必要根据页面标签定义的图片资源挨个请求
  

  这也就是为什么新版本的http要支持长毗连:
  

• 如果还采用短毗连,一个毗连=一个资源,那万一网页有几百张图片资源,那不得毗连死
  

    介绍

  插入图片资源的html语法: -- HTML 图像
  

• 
  
  

  图片资源着实就是二进制文件,它必要被上层以某种格式解释,才气呈现出我们想要看到的样子
  

• 所以就必要添加conten-type字段,来指定该资源的类型
  
• 我们之前都没有利用过这个字段,所以他默认以html格式解释
  
• 如果是图片的话,就得是image/jpeg / image/png
  

  但是,那么多资源,怎样识别哪个资源是那个类型呢?
  

• 我们就必要继承细分url了
  
• url不是记录了客户端要访问的资源路径吗,就肯定会带上资源的文件名
  
• 如果文件名带有.jpg / .png后缀,则为图片资源
  
• 如果带有.html后缀,则是我们平常的网页资源
  
• 如果是其他的,就默认以html格式解释(这里就简朴一点处理惩罚啦)
  

  那么,有了后缀,我们还必要将后缀与对应的conten-type的添补值相关联
  

• 所以我们必要定义一个键值对容器
  

  既然图片是二进制,那如果还利用[读取文本文件的一行一行读]的方式就不可了
  

• 必要增长一个读取二进制的函数,用来区分两者
  

    代码

  除了增长了读取图片资源的功能,我还把代码结构修改了很多
  http_server.hpp

1. #pragma once
3. #include <signal.h>
4. #include <unistd.h>
5. #include <cstring>
6. #include <functional>
7. #include <unordered_map>
9. #include "socket.hpp"
10. #include "Serialization.hpp"
12. static MY_SOCKET my_socket;
14. #define buff_size 1024 * 30
16. class http_server
17. {
18. public:
19.     http_server(const uint16_t port, const std::string &ip = "0.0.0.0")
20.         : port_(port), ip_(ip)
21.     {
22.         content_type_[".html"] = "text/html";
23.         content_type_[".png"] = "image/png";
24.         content_type_[".jpg"] = "image/jpeg";
25.         content_type_[".jpeg"] = "image/jpeg";
26.     }
27.     ~http_server() {}
28.     void run()
29.     {
30.         init();
31.         while (true)
32.         {
33.             uint16_t client_port;
34.             std::string client_ip;
35.             lg(DEBUG, "accepting ...");
36.             int sockfd = my_socket.Accept(client_ip, client_port);
37.             if (sockfd == -1)
38.             {
39.                 continue;
40.             }
41.             lg(INFO, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, client_ip.c_str(), client_port);
43.             int ret = fork();
44.             if (ret == 0)
45.             {
46.                 my_socket.Close();
47.                 char buffer[buff_size];
48.                 std::string in_buffer;
50.                 while (true)
51.                 {
52.                     memset(buffer, 0, sizeof(buffer));
53.                     int n = read(sockfd, buffer, sizeof(buffer)); //"size"\n"a op b"\n
54.                     if (n > 0)
55.                     {
56.                         buffer[n] = 0;
57.                         in_buffer += buffer; // 连续读取
58.                         lg(INFO, "get request: \n%s", in_buffer.c_str());
60.                         // 构建请求
61.                         request req;
62.                         req.deserialize(in_buffer);
64.                         //lg(DEBUG, "path: %s ,url: %s ", (req.path_).c_str(), (req.url_).c_str());
66.                         // 构建响应
67.                         response res;
68.                         handle_response(res, req);
70.                         // 响应序列化
71.                         std::string content;
72.                         res.serialize(content);
74.                         write(sockfd, content.c_str(), content.size());
75.                     }
76.                     else if (n == 0)
77.                     {
78.                         lg(INFO, "%s quit", client_ip.c_str());
79.                         break;
80.                     }
81.                     else // 读出错误
82.                     {
83.                         break;
84.                     }
85.                 }
86.                 exit(0);
87.                 close(sockfd);
88.             }
89.         }
90.     }
92. private:
93.     void init()
94.     {
95.         signal(SIGPIPE, SIG_IGN);
96.         signal(SIGCHLD, SIG_IGN);
98.         my_socket.Socket();
99.         my_socket.Bind(port_);
100.         my_socket.Listen();
101.         lg(INFO, "server init done");
102.     }
103.     void handle_response(response &res, request &req)
104.     {
105.         int code = req.code_;
106.         std::string path = req.path_;
107.         std::string content_type_data = content_type_[req.suffix_];
108.         //lg(DEBUG, "content_type_data: %s", content_type_data.c_str());
110.         res.version_ = "HTTP/1.1";
111.         if (code == 302)
112.         {
113.             res.code_ = 302;
114.             res.desc_ = "Found";
116.             std::string cl = "Location: ";
117.             cl += "https://www.qq.com";
118.             (res.title_).push_back(cl);
119.             return ;
120.         }
122.         if (code == 404)
123.         {
124.             res.code_ = 404;
125.             res.desc_ = "Not Found";
126.         }
127.         else
128.         {
129.             res.code_ = 200;
130.             res.desc_ = "OK";
131.         }
133.         // 将读取网页和图片资源的方式分开
134.         if (req.suffix_ == ".html")
135.         {
136.             res.text_ = get_page(path);
137.             //lg(DEBUG, "text: %s", (res.text_).c_str());
138.         }
139.         else
140.         {
141.             res.text_ = b_get_page(path);
142.         }
144.         //  构建响应报头
145.         std::string cl = "Content-Length: ";
146.         cl += std::to_string((res.text_).size());
147.         //lg(DEBUG, "text_size: %d", (res.text_).size());
148.         (res.title_).push_back(cl);
150.         cl = "Content-Type: ";
151.         cl += content_type_data;
152.         (res.title_).push_back(cl);
153.     }
155. private:
156.     uint16_t port_;
157.     std::string ip_;
159.     std::unordered_map<std::string, std::string> content_type_;
160. };

复制代码

Serialization.hpp

1. #pragma once
3. #include <string>
4. #include <vector>
5. #include <sstream>
6. #include <fstream>
7. #include <iostream>
9. #define protocol_sep "\r\n"
10. #define blank_sep ' '
11. #define root_path "./root_page"
12. #define def_file "root.html"
14. std::string get_page(std::string path)
15. {
16.     std::string content, tmp;
17.     std::ifstream in(path.c_str());
18.     if (!in.is_open())
19.     {
20.         return "";
21.     }
22.     while (std::getline(in, tmp))
23.     {
24.         content += tmp;
25.     }
26.     in.close();
28.    // printf("content : %s", content.c_str());
29.     return content;
30. }
31. std::string b_get_page(std::string path)
32. {
33.     std::ifstream in(path.c_str(), std::ios_base::binary);
34.     if (!in.is_open())
35.     {
36.         return "";
37.     }
38.     in.seekg(0, std::ios_base::end);
39.     auto len = in.tellg();
40.     in.seekg(0, std::ios_base::beg);
42.     std::string content;
43.     content.resize(len);
45.     in.read((char *)content.c_str(), content.size());
46.     in.close();
48.     return content;
49. }
51. class request
52. {
53. public:
54.     request()
55.         : type_(""), url_(""), version_(""), text_(""), path_(""), code_(0), suffix_("") {}
56.     bool deserialize(std::string &content)
57.     {
58.         std::string tmp;
59.         size_t left = 0;
60.         while (true)
61.         {
62.             size_t pos = content.find(protocol_sep, left);
63.             if (pos == std::string::npos)
64.             {
65.                 return false;
66.             }
68.             tmp = content.substr(left, pos - left); // 左闭右开
69.             left = pos + 2;
70.             if (tmp.empty()) // 读到空行
71.             {
72.                 break;
73.             }
74.             else
75.             {
76.                 title_.push_back(tmp);
77.             }
78.         }
80.         // 判断是否有正文
81.         std::string comp = "Content-Length: ";
82.         bool is_find = false;
83.         int size = 0;
84.         for (auto &it : title_)
85.         {
86.             size_t pos = it.find(comp);
87.             if (pos != std::string::npos)
88.             {
89.                 ssize_t right = it.find(protocol_sep);
90.                 std::string s_size = it.substr(pos + comp.size(), right - pos - comp.size());
91.                 size = stoi(s_size);
92.                 is_find = true;
93.                 break;
94.             }
95.         }
96.         if (!is_find)
97.         { // 没有Content-Length字段
98.             content.erase(0, left + 2);
99.         }
100.         else
101.         {
102.             text_ = content.substr(left + 2, size);
103.             content.erase(0, left + 2 + size);
104.         }
106.         handle_path();
108.         return true;
109.     }
111. private:
112.     void handle_path() // 构建访问资源的路径
113.     {
114.         // 细分请求行
115.         std::string request_line = title_[0];
116.         std::stringstream ss(request_line);
117.         ss >> type_ >> url_ >> version_;
119.         // 构建路径
120.         path_ = root_path;
121.         if (url_ == "/")
122.         {
123.             path_ += "/";
124.             path_ += def_file;
125.         }
126.         else if (url_ == "/302")
127.         {
128.             code_ = 302; // 这里设置为重定向到百度页面,所以不能走本地读取
129.             return;
130.         }
131.         else
132.         {
133.             path_ += url_;
134.         }
136.         // 判断该资源是否存在
137.         if (get_page(path_).empty())
138.         {
139.             code_ = 404; // 需要告诉响应,这里发生了404错误
140.             path_ = root_path;
141.             path_ += "/";
142.             path_ += "404_err.html";
143.         }
145.         // 拿到资源后缀
146.         size_t pos = path_.rfind(".");
147.         if (pos == std::string::npos)
148.         {
149.             suffix_ = ".html";
150.         }
151.         else
152.         {
153.             suffix_ = path_.substr(pos);
154.         }
155.     }
157. public:
158.     std::string type_;
159.     std::string url_;
160.     std::string path_;
161.     int code_;
162.     std::string suffix_;
163.     std::string version_;
164.     std::vector<std::string> title_;
165.     std::string text_;
166. };
168. class response
169. {
170. public:
171.     response()
172.         : version_(""), code_(0), desc_(""), text_("") {}
173.     void serialize(std::string &content)
174.     {
175.         // 响应行
176.         std::string header = version_;
177.         header += blank_sep;
178.         header += std::to_string(code_);
179.         header += blank_sep;
180.         header += desc_;
181.         header += protocol_sep;
183.         // 响应报头
184.         std::string attribute;
185.         for (auto &it : title_)
186.         {
187.             attribute += it;
188.             attribute += protocol_sep;
189.         }
191.         content = header + attribute + protocol_sep + text_;
192.     }
194. public:
195.     std::string version_;
196.     int code_;
197.     std::string desc_;
198.     std::vector<std::string> title_;
199.     std::string text_;
200. };

复制代码

root_page.html

1. <!DOCTYPE html>
2. <html>
4. <head>
5.     <meta charset="UTF-8">
6.     <title>my title</title>
7. </head>
9. <body>
10.     <h1>hello.</h1>
11.     <h2>hello..</h2>
12.     <h3>hello...</h3>
13.     <p>hello world!</p>
15.     <form action="a/page1.html" method="get">
16.         name:<input type="text" name="name"><br>
17.         password:<input type="password" name="password"><br>
18.         <input type="submit" name="submit">
19.     </form>
21.     <img src="1.jpeg" alt="猫猫" width="500" height="400">
23.     <h2>跳转至第一个页面</h2>
24.     <p><a href="a/page1.html">page1</a></p>
25.     <h2>跳转至第二个页面</h2>
26.     <p><a href="a/b/page2.html">page2</a></p>
28. </body>
30. </html>

复制代码

   示例 

  当我们在首页放上我们的图片资源时
  

• 访问首页后,浏览器就会根据页面上的html标签继承申请其他资源
  
• 
  
  
• 这是网页的样式(可以看到图片成功被加载出来了):
  
• 
  
  

  
修改为多线程版(短毗连) 

   介绍

  服务器收到一个毗连后,就创建一个线程去处理惩罚请求
  

• 并且添加了重连功能
  

  留意:
  

• 我们这里是短毗连版本,一次毗连=处理惩罚一次请求
  
• 但纵然是短毗连,也得保证读取到的数据是一份完备的请求
  
• 所以我在线程外部定义了一个缓冲区,用于保存处理惩罚过程中剩下的数据(因为它有大概是其他毗连的一部分)
  
• 而线程内部在反序列化时,将完备请求从缓冲区中剥离
  

    代码

1. #pragma once
3. #include <signal.h>
4. #include <unistd.h>
5. #include <cstring>
6. #include <functional>
7. #include <pthread.h>
8. #include <unordered_map>
10. #include "socket.hpp"
11. #include "Serialization.hpp"
13. static MY_SOCKET my_socket;
15. #define buff_size 1024 * 30
17. class http_server;
18. struct thread_data
19. {
20.     int sockfd_;
21.     std::string ip_;
22.     std::string &in_buffer_;
23.     http_server *this_;
24. };
26. class http_server
27. {
28. public:
29.     http_server(const uint16_t port, const std::string &ip = "0.0.0.0")
30.         : port_(port), ip_(ip)
31.     {
32.         content_type_[".html"] = "text/html";
33.         content_type_[".png"] = "image/png";
34.         content_type_[".jpg"] = "image/jpeg";
35.         content_type_[".jpeg"] = "image/jpeg";
36.     }
37.     ~http_server() {}
38.     void run()
39.     {
40.         init();
41.         while (true)
42.         {
43.             uint16_t client_port;
44.             std::string client_ip;
46.             // 一个线程处理一次请求(短连接)
47.             pthread_t pid;
48.             std::string in_buffer;
50.             int sockfd = 0;
51.             int count = 5;
52.             do
53.             {
54.                 lg(DEBUG, "accepting ...");
55.                 sockfd = my_socket.Accept(client_ip, client_port);
56.                 if (sockfd != -1 || --count == 0)
57.                 {
58.                     break;
59.                 }
60.             } while (true);
61.             if (sockfd == -1)
62.             {
63.                 lg(ERROR, "accepting error");
64.             }
66.             lg(INFO, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, client_ip.c_str(), client_port);
68.             thread_data *td = new thread_data{sockfd, client_ip, in_buffer, this};
69.             lg(DEBUG, "create pthread");
70.             pthread_create(&pid, nullptr, entry, reinterpret_cast<void *>(td));
72.             // 一个进程服务一个客户端
74.             // lg(DEBUG, "accepting ...");
75.             // int sockfd = my_socket.Accept(client_ip, client_port);
76.             // if (sockfd == -1)
77.             // {
78.             //     continue;
79.             // }
80.             // lg(INFO, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, client_ip.c_str(), client_port);
81.             //  int ret = fork();
82.             //  if (ret == 0)
83.             //  {
84.             //      my_socket.Close();
85.             //  char buffer[buff_size];
86.             //  std::string in_buffer;
88.             // while (true)
89.             // {
90.             //     memset(buffer, 0, sizeof(buffer));
91.             //     int n = read(sockfd, buffer, sizeof(buffer)); //"size"\n"a op b"\n
92.             //     if (n > 0)
93.             //     {
94.             //         buffer[n] = 0;
95.             //         in_buffer += buffer; // 连续读取
96.             //         lg(INFO, "get request: \n%s", in_buffer.c_str());
98.             //         // 构建请求
99.             //         request req;
100.             //         req.deserialize(in_buffer);
102.             //         // lg(DEBUG, "path: %s ,url: %s ", (req.path_).c_str(), (req.url_).c_str());
104.             //         // 构建响应
105.             //         response res;
106.             //         handle_response(res, req);
108.             //         // 响应序列化
109.             //         std::string content;
110.             //         res.serialize(content);
112.             //         write(sockfd, content.c_str(), content.size());
113.             //     }
114.             //     else if (n == 0)
115.             //     {
116.             //         lg(INFO, "%s quit", client_ip.c_str());
117.             //         break;
118.             //     }
119.             //     else // 读出错误
120.             //     {
121.             //         break;
122.             //     }
123.             // }
124.             //     exit(0);
125.             //     close(sockfd);
126.             // }
127.         }
128.     }
130. private:
131.     void init()
132.     {
133.         signal(SIGPIPE, SIG_IGN);
134.         signal(SIGCHLD, SIG_IGN);
136.         my_socket.Socket();
137.         my_socket.Bind(port_);
138.         my_socket.Listen();
139.         lg(INFO, "server init done");
140.     }
141.     void handle_response(response &res, request &req)
142.     {
143.         int code = req.code_;
144.         std::string path = req.path_;
145.         std::string content_type_data = content_type_[req.suffix_];
146.         // lg(DEBUG, "content_type_data: %s", content_type_data.c_str());
148.         res.version_ = "HTTP/1.1";
149.         if (code == 302)
150.         {
151.             res.code_ = 302;
152.             res.desc_ = "Found";
154.             std::string cl = "Location: ";
155.             cl += "https://www.qq.com";
156.             (res.title_).push_back(cl);
157.             return;
158.         }
160.         if (code == 404)
161.         {
162.             res.code_ = 404;
163.             res.desc_ = "Not Found";
164.         }
165.         else
166.         {
167.             res.code_ = 200;
168.             res.desc_ = "OK";
169.         }
171.         // 将读取网页和图片资源的方式分开
172.         if (req.suffix_ == ".html")
173.         {
174.             res.text_ = get_page(path);
175.             // lg(DEBUG, "text: %s", (res.text_).c_str());
176.         }
177.         else
178.         {
179.             res.text_ = b_get_page(path);
180.         }
182.         //  构建响应报头
183.         std::string cl = "Content-Length: ";
184.         cl += std::to_string((res.text_).size());
185.         // lg(DEBUG, "text_size: %d", (res.text_).size());
186.         (res.title_).push_back(cl);
188.         cl = "Content-Type: ";
189.         cl += content_type_data;
190.         (res.title_).push_back(cl);
191.     }
192.     static void *entry(void *args)
193.     {
194.         pthread_detach(pthread_self());
196.         thread_data *td = reinterpret_cast<thread_data *>(args);
197.         int sockfd = td->sockfd_;
198.         std::string ip = td->ip_;
199.         std::string in_buffer = td->in_buffer_;
200.         http_server *it = td->this_;
202.         // 读取请求
203.         char buffer[buff_size];
204.         bool flag = true;
205.         request req;
206.         while (true) // 虽说是短连接,但也得确保读出来的内容是一个完整的请求
207.         {
208.             memset(buffer, 0, sizeof(buffer));
209.             int n = read(sockfd, buffer, sizeof(buffer));
210.             if (n > 0)
211.             {
212.                 buffer[n] = 0;
213.                 in_buffer += buffer; // 连续读取
214.                 lg(INFO, "get request: \n%s", in_buffer.c_str());
216.                 // 构建请求
217.                 flag = req.deserialize(in_buffer);
218.                 if (flag == false)
219.                 {
220.                     continue;
221.                 }
222.                 else
223.                 {
224.                     break;
225.                 }
226.             }
227.             else if (n == 0)
228.             {
229.                 lg(INFO, "%s quit", ip.c_str());
230.                 return nullptr;
231.             }
232.             else
233.             {
234.                 lg(ERROR, "%s read error", ip.c_str());
235.                 return nullptr;
236.             }
237.         }
239.         // lg(DEBUG, "path: %s ,url: %s ", (req.path_).c_str(), (req.url_).c_str());
241.         // 构建响应
242.         response res;
243.         it->handle_response(res, req);
245.         // 响应序列化
246.         std::string content;
247.         res.serialize(content);
249.         write(sockfd, content.c_str(), content.size());
251.         //  销毁资源
252.         delete td;
253.         close(sockfd);
255.         return nullptr;
256.     }
258. private:
259.     uint16_t port_;
260.     std::string ip_;
262.     std::unordered_map<std::string, std::string> content_type_;
263. };

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。