[项目]搭建一个HTTP_SERVER

1.项目先容

   该项目是一个基于http和tcp协议自主实现的WebServer,用于实现欣赏器对服务器的简单哀求,然后吸收服务器返回的处理哀求数据,目的是为了让学习者更好的对网络连接和相关协议举行明确,同时制作出像网络在线盘算机,音视频哀求播放,大概雷同博客的功能,该夺目利用到的紧张技能有网络编程(socket),多线程编程,cgi技能,管道通信等。
  2.详细编码实现

2.1 tcp_server

1. #pragma  once
2. #include <iostream>
3. #include "LOG.hpp"
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <cstdlib>
7. #include <cstring>
8. #include <pthread.h>
9. #include <netinet/in.h>
10. #include <arpa/inet.h>
12. #define PORT 8081
13. #define BACKLOG 5
14. class TcpServer{
15.     private:
16.         int listen_sock;
17.         int port;
18.         static TcpServer* tcpserver;
19.     private:
20.         TcpServer(int _port = PORT):listen_sock(),port(_port){ }
21.         ~TcpServer(){}
22.     public:
23.         static TcpServer* GetInstance(int _port = PORT){
24.             static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
25.             if(tcpserver == nullptr){
26.                 pthread_mutex_lock(&lock);
27.                 if(tcpserver == nullptr){
28.                     tcpserver = new TcpServer(_port);
29.                     tcpserver->InitTcpServer();
30.                 }
31.                 pthread_mutex_unlock(&lock);
32.             }
33.             return tcpserver;
34.         }
35.         void InitTcpServer(){
36.             CreateSock();
37.             BindSock();
38.             ListenSock();
39.         }
40.         void CreateSock(){
41.             listen_sock = socket(AF_INET,SOCK_STREAM,0);
42.             if(listen_sock < 0){
43.                 LOG(INFO,"Create Sock Unsucess!");
44.                 exit(1);
45.             }
46.             int opt = 1;
47.             setsockopt(listen_sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
48.             LOG(INFO,"Create Sock Sucess!");
49.         }
50.         void BindSock(){
51.             struct sockaddr_in local;
52.             memset(&local,0,sizeof(local));
53.             local.sin_family = AF_INET;
54.             local.sin_port = htons(port);
55.             local.sin_addr.s_addr = INADDR_ANY;  //云服务器不可以直接绑定ip
56.             if(bind(listen_sock,(struct sockaddr*)&local,sizeof(local))<0){
57.                 LOG(INFO,"Bind Sock Unsucess!");
58.                 exit(2);
59.             }
60.             LOG(INFO,"Bind Sock Sucess!");
61.         }
63.         void ListenSock(){
64.             if(listen(listen_sock,BACKLOG)<0){
65.                 LOG(INFO,"Listen Sock Unsucess!");
66.                 exit(3);
67.             }
68.             LOG(INFO,"Listen Sock Sucess!");
69.         }
71.         int GetListenSock(){
72.             return listen_sock;
73.         }
74.         
75. };
76. TcpServer*  TcpServer::tcpserver = nullptr;

复制代码

 2.2 http_server

1. #pragma once
2. #include "TcpServer.hpp"
3. #include "Protocol.hpp"
4. #include "LOG.hpp"
5. #include "Task.hpp"
6. #include "ThreadPool.hpp"
8. #define PORT 8081
9. class HttpServer{
10.     private:
11.         int sock;
12.         int port;
13.         int stop;
14.         TcpServer* tcpserver;
15.     public:
16.         HttpServer(int _port = PORT):port(_port),stop(false),tcpserver(nullptr){}
17.         void InitHttpServer(){
18.             // 防止对端(client and server)断开发送SIGPIPE信号时,执行默认动作
19.             signal(SIGPIPE,SIG_IGN);
20.         }
22.         void Loop(){
23.             tcpserver = TcpServer::GetInstance(port);
24.             while(!stop){
25.                 struct sockaddr_in peer;
26.                 socklen_t len = sizeof(peer);
27.                 memset(&peer,0,sizeof(peer));
28.                 sock = accept(tcpserver->GetListenSock(),(struct sockaddr*)&peer,&len);
29.                 LOG(INFO,"Begin Get A New Link!");
30.                 if(sock < 0){
31.                     LOG(INFO,"Accept Socket Unsucess!");
32.                     continue;
33.                 }
34.                 LOG(INFO,"Begin Proess Request!");
35.                 TASK task(sock);
36.                 ThreadPool::GetInstance()->PushTask(task);
37.             }
38.         }
39.        ~HttpServer(){}
40. };

复制代码

2.3 日志体系

1. #pragma  once
2. #include <string>
3. #include <iostream>
4. #include <cstdio>
5. #include <time.h>
6. #define INFO    1
7. #define WARNING 2
8. #define ERROR   3
9. #define FATAL   4
10. #define LOG(level,message) log(#level,message,__FILE__,__LINE__)
11. void log(std::string level,std::string message,std::string fname,int eline){
12.         struct tm t;
13.         time_t now = time(NULL);
14.         localtime_r(&now,&t);
16.         printf("[%-7s][%-4d-%02d-%02d %02d:%02d:%02d][%-30s][%-15s][%-4d]\n",\
17.                 level.c_str(),t.tm_year+1900,t.tm_mon+1,t.tm_mday,t.tm_hour,t.tm_min,t.tm_sec,\
18.                 message.c_str(),fname.c_str(),eline);
19.     }

复制代码

2.4 Protocol协议的搭建

1. class EndPoint{
2.     private:
3.         int sock;
4.         bool stop;
5.         HttpRequest http_request;
6.         HttpResbonse http_resbonse;
7.     public:
8.         EndPoint(int _sock):sock(_sock),stop(false){}
11.         int IsStop(){
12.             return stop;
13.         }
15.         void RecvHttpRequest(){
16.             if((!Recv_Parse_HttpRequest_Line()) && \
17.                 (!Recv_Parse_HttpRequest_Head()) && \
18.                 (!Recv_HttpRequest_Body())){}
19.             }
21.         int  Recv_Parse_HttpRequest_Line(){
22.             LOG(INFO,"Begin Recv Request");
23.             //recv
24.             if(Utility::ReadLine(sock,http_request.request_line)> 0){
25.                 http_request.request_line.back() = 0;
26.                 LOG(INFO,http_request.request_line);
27.             }
28.             else{
29.                 stop = true;
30.                 return stop;
31.             }
32.             //parse
33.             std::stringstream ss(http_request.request_line);
34.             ss>>http_request.method>>http_request.uri>>http_request.version;
35.             //toupper
36.             auto& mt = http_request.method;
37.             std::transform(mt.begin(),mt.end(),mt.begin(),::toupper);
39.             size_t pos = http_request.path.rfind(".");
40.             if(pos != std::string::npos){
41.                 http_request.suffix = http_request.path.substr(pos+1);
42.             }
43.             return stop;
44.         }
46.         int Recv_Parse_HttpRequest_Head(){
47.             //recv
48.             std::string line = "";
49.             while(true){
50.                 line.clear();
51.                 if(Utility::ReadLine(sock,line)<=0){
52.                     stop = true;
53.                     return stop;
54.                 }
55.                 if(line == "\n"){
56.                     http_request.blank = line;
57.                     break;
58.                 }
59.                 line.back() = 0;
60.                 http_request.request_header.push_back(line);
61.                 LOG(INFO,line);
62.             }
64.             //parse
65.             for(auto& item:http_request.request_header) {
66.                 std::string key,value;
67.                 Utility::CutString(item,key,value,": ");
68.                 http_request.request_header_kv[key] = value;
69.             }
70.             return stop;
71.         }
73.         int Recv_HttpRequest_Body(){
74.             auto& mt = http_request.method;
75.             if(mt == "POST"){
76.                 auto item = http_request.request_header_kv.find("Content-Length");
77.                 if(item != http_request.request_header_kv.end()){
78.                     http_request.content_length = atoi(item->second.c_str());
79.                     int size = http_request.content_length;
80.                     while(size){
81.                         char ch;
82.                         size_t s = recv(sock,&ch,1,0);
83.                         if(s > 0){
84.                             http_request.request_body.push_back(ch);
85.                             size--;
86.                         }
87.                         else if(s == 0){
88.                             break;
89.                         }
90.                         else {
91.                             stop = true;
92.                             return stop;
93.                             LOG(ERROR,"Recv RequestBody Error");
94.                             exit(1);
95.                         }
96.                     }
97.                 }
98.             }
99.             return stop;
100.         }
102.         void Build_HttpResbonse(){
103.             http_request.path = "wwwroot";
104.             auto& mt = http_request.method;
105.             std::string tmp;
106.             struct stat buf;
108.             //检查方法是否合法
109.             if(mt!= "GET" && mt != "POST"){
110.                 LOG(INFO,"Request Method Is Not Law!");
111.                 http_resbonse.status_code = NOT_FOUND;
112.                 goto END;
113.             }
114.             if(mt == "GET"){
115.                 //如果是get方法,检查是否带参
116.                 size_t pos = http_request.uri.find("?");
117.                 if(pos != std::string::npos){
118.                     Utility::CutString(http_request.uri,tmp,http_request.query,"?");
119.                     http_request.cgi = true;
120.                 }
121.                 else {
122.                     tmp = http_request.uri;
123.                 }
124.             }
125.             else if(mt == "POST"){
126.                 tmp = http_request.uri;
127.                 http_request.cgi = true;
128.             }
129.             else{}
132.             //拼接web根目录
133.             http_request.path += tmp;
134.             if(http_request.path.back() == '/'){
135.                 http_request.path += "index.html";
136.             }
138.             //检查资源是否存在
139.             if(!stat(http_request.path.c_str(),&buf)){
140.                 //检查资源是否是目录
141.                 if(S_ISDIR(buf.st_mode)){
142.                     http_request.path += "/";
143.                     http_request.path += "index.html";
144.                     stat(http_request.path.c_str(),&buf);
145.                 }//检查资源是否是可自行文件
146.                 else if((S_IXUSR & buf.st_mode)||(S_IXGRP & buf.st_mode)||(S_IXOTH & buf.st_mode)){
147.                     http_request.cgi = true;
148.                 }
149.                 http_request.size = buf.st_size;
150.             }
151.             else {
152.                 LOG(INFO,http_request.path +"Resorce Is Not Exist");
153.                 http_resbonse.status_code = NOT_FOUND;
154.                 goto END;
155.             }
157.             if(http_request.cgi){
158.                 http_resbonse.status_code = HandlerCgi();
159.             }
160.             else{
161.                 http_resbonse.status_code = HandlerNonCgi();
162.             }
163. END:
164.             Build_HttpResbonseHelper();
165.         }
167.         int HandlerNonCgi(){
168.             auto& path = http_request.path;
169.             http_resbonse.fd = open(path.c_str(),O_RDONLY);
170.             if(http_resbonse.fd > 0){
171.                 return OK;
172.             }
173.             return NOT_FOUND;
175.         }
176.         int HandlerCgi(){
177.             auto& bin = http_request.path;
178.             auto& query_get = http_request.query;
179.             auto& query_post = http_request.request_body;
180.             int upfd[2],downfd[2];
181.             if(pipe(upfd)<0 || pipe(downfd)<0){
182.                 LOG(ERROR,"PIPE ERROR");
183.                 return ERROR_SERVER;
184.             }
186.             pid_t pid = fork();
187.             if(pid == 0){
188.                 close(upfd[0]);
189.                 close(downfd[1]);
191.                 dup2(downfd[0],0);
192.                 dup2(upfd[1],1);
194.                  std::string method = "METHOD=";
195.                 method += http_request.method;
196.                 putenv((char*)method.c_str());         
198.                 if(http_request.method == "GET"){
199.                     std::string query = "QUERY=";
200.                     query += query_get;
201.                     putenv((char*)query.c_str());
202.                 }
203.                 else if(http_request.method == "POST"){
204.                     int cl = http_request.content_length;
205.                     std::string content_length = "CONTENT_LENGTH=";
206.                     content_length += std::to_string(cl);
207.                     putenv((char*)content_length.c_str());
208.                 }
210.                 execl(bin.c_str(),bin.c_str(),nullptr);
212.                 exit(1);
213.             }
214.             else if(pid > 0){
215.                 close(upfd[1]);
216.                 close(downfd[0]);
218.                 std::string& method = http_request.method;
220.                 if(method == "POST"){
221.                     const char* query = query_post.c_str();
222.                     ssize_t total = 0,size = 0;
223.                     while(total < http_request.content_length && \
224.                             (size = write(downfd[1],query+total,http_request.content_length - total)) > 0){
225.                         total += size;
226.                     }
227.                 }
229.                 std::string& body = http_resbonse.resbonse_body;
230.                 char ch = 0;
231.                 while(read(upfd[0],&ch,1) > 0){
232.                     body.push_back(ch);
233.                 }
234.                 int status = 0;
235.                 int ret = waitpid(pid,&status,0);
236.                 if(ret == pid){
237.                     if(WIFEXITED(status) && !WEXITSTATUS(status)){
238.                         return OK;
239.                     }
240.                     else {
241.                         LOG(ERROR,"----------");
242.                         return ERROR_SERVER;
243.                     }
244.                 }
245.                 close(upfd[0]);
246.                 close(downfd[1]);
247.             }
248.             else{
249.                 LOG(ERROR,"Create SonProcess Unsucess");
250.                 return 404;
251.             }
252.         }
254.         void Build_HttpResbonseHelper(){
255.             int code = http_resbonse.status_code;
256.             auto& status_line = http_resbonse.resbonse_line;
257.             status_line = VERSION;
258.             status_line += " ";
259.             status_line += std::to_string(code);
260.             status_line += " ";
261.             status_line += StatusCodeDesc(code);
262.             status_line += LINE_END;
264.             if(code == 200){
265.                 BuildOKResbonse();
266.             }
267.             else {
268.                 BuildErrorResbonse(code);
269.             }
270.         }
271.         void BuildOKResbonse(){
272.             std::string line = "Content-Length: ";
273.             if(http_request.cgi){
274.                 line += std::to_string(http_resbonse.resbonse_body.size());
275.             }
276.             else {
277.                 line += std::to_string(http_request.size);
278.             }
279.             line+=LINE_END;
280.             http_resbonse.resbonse_header.push_back(line);
282.             line = "Content-Type: ";
283.             line += SuffixDesc(http_request.suffix);
284.             line += LINE_END;
285.             http_resbonse.resbonse_header.push_back(line);
286.         }
287.         void BuildErrorResbonse(int code){
288.             http_request.cgi = false;
289.             std::string page = GetErrorFile(code);
290.             std::cout<<"page"<<page<<std::endl;
291.             http_resbonse.fd = open(page.c_str(),O_RDONLY);
292.             if(http_resbonse.fd > 0){
293.                 struct stat buf;
294.                 stat(page.c_str(),&buf);
295.                 http_request.size = buf.st_size;
297.                 std::string line = "Content-type: text/html";
298.                 line += LINE_END;
299.                 http_resbonse.resbonse_header.push_back(line);
301.                 line = "Content-Length: ";
302.                 line += std::to_string(buf.st_size);
303.                 line += LINE_END;
304.                 http_resbonse.resbonse_header.push_back(line);
305.             }
306.             
307.         }
309.         void Send_HttpResbonse(){
310.             auto& line = http_resbonse.resbonse_line;
312.             send(sock,line.c_str(),line.size(),0);
313.             for(auto& item : http_resbonse.resbonse_header){
314.                 send(sock,item.c_str(),item.size(),0);
315.             }
316.             send(sock,http_resbonse.blank.c_str(),http_resbonse.blank.size(),0);
317.             if(http_request.cgi){
318.                 send(sock,http_resbonse.resbonse_body.c_str(),http_resbonse.resbonse_body.size(),0);
319.             }
320.             else {
321.                 sendfile(sock,http_resbonse.fd,nullptr,http_request.size);
322.                 close(http_resbonse.fd);
323.             }
324.         }
326.         ~EndPoint(){
327.             close(sock);
328.         }
329. };

复制代码

2.5 CGI技能

1.    int HandlerCgi(){
2.             auto& bin = http_request.path;
3.             auto& query_get = http_request.query;
4.             auto& query_post = http_request.request_body;
5.             int upfd[2],downfd[2];
6.             if(pipe(upfd)<0 || pipe(downfd)<0){
7.                 LOG(ERROR,"PIPE ERROR");
8.                 return ERROR_SERVER;
9.             }
11.             pid_t pid = fork();
12.             if(pid == 0){        //子进程导入环境变量
13.                 close(upfd[0]);
14.                 close(downfd[1]);
16.                 dup2(downfd[0],0);
17.                 dup2(upfd[1],1);
19.                  std::string method = "METHOD=";
20.                 method += http_request.method;
21.                 putenv((char*)method.c_str());         
23.                 if(http_request.method == "GET"){
24.                     std::string query = "QUERY=";
25.                     query += query_get;
26.                     putenv((char*)query.c_str());
27.                 }
28.                 else if(http_request.method == "POST"){
29.                     int cl = http_request.content_length;
30.                     std::string content_length = "CONTENT_LENGTH=";
31.                     content_length += std::to_string(cl);
32.                     putenv((char*)content_length.c_str());
33.                 }
35.                 execl(bin.c_str(),bin.c_str(),nullptr);
37.                 exit(1);
38.             }
39.             else if(pid > 0){    //父进程写入数据 和 读取数据
40.                 close(upfd[1]);
41.                 close(downfd[0]);
43.                 std::string& method = http_request.method;
45.                 if(method == "POST"){
46.                     const char* query = query_post.c_str();
47.                     ssize_t total = 0,size = 0;
48.                     while(total < http_request.content_length && \
49.                             (size = write(downfd[1],query+total,http_request.content_length - total)) > 0){
50.                         total += size;
51.                     }
52.                 }
54.                 std::string& body = http_resbonse.resbonse_body;
55.                 char ch = 0;
56.                 while(read(upfd[0],&ch,1) > 0){
57.                     body.push_back(ch);
58.                 }
59.                 int status = 0;
60.                 int ret = waitpid(pid,&status,0);
61.                 if(ret == pid){
62.                     if(WIFEXITED(status) && !WEXITSTATUS(status)){
63.                         return OK;
64.                     }
65.                     else {
66.                         LOG(ERROR,"----------");
67.                         return ERROR_SERVER;
68.                     }
69.                 }
70.                 close(upfd[0]);
71.                 close(downfd[1]);
72.             }
73.             else{
74.                 LOG(ERROR,"Create SonProcess Unsucess");
75.                 return 404;
76.             }
77.         }

复制代码

test_cgi

1. #include <iostream>
2. #include <cstdlib>
3. #include <string>
4. #include <unistd.h>
5. bool GetQuery(std::string& query){
6.     std::string method = getenv("METHOD");
7.     if(method == "GET"){
8.         query = getenv("QUERY");
9.     }
10.     else if(method == "POST"){
11.         int content_length = atoi(getenv("CONTENT_LENGTH"));
12.         char ch = 0;
13.         while(content_length){
14.             ssize_t s = read(0,&ch,1);
15.             if(s>0){
16.                 content_length--;
17.                 query.push_back(ch);
18.             }
19.             else if(s == 0){
20.                 break;
21.             }
22.             else{
23.                 return false;
24.             }
25.         }
26.     }
27.     return true;
28. }
30. void CutQuery(std::string& tar,std::string& key,std::string& value,const std::string& sep){
31.     size_t pos = tar.find(sep);
32.     if(pos != std::string::npos){
33.         key = tar.substr(0,pos);
34.         value = tar.substr(pos+sep.size());
35.     }
36. }
38. int main(){
39.     std::string query;
40.     GetQuery(query);
42.     std::string str1,str2;
43.     std::string name1,name2;
44.     std::string value1,value2;
45.     CutQuery(query,str1,str2,"&");
46.     CutQuery(str1,name1,value1,"=");
47.     CutQuery(str2,name2,value2,"=");
49.     std::cout<<name1<<":"<<value1<<std::endl;
50.     std::cout<<name2<<":"<<value2<<std::endl;
51.     return 0;
52. }

复制代码

2.5 线程池技能

1. #pragma once
2. #include <iostream>
3. #include "Task.hpp"
4. #include <pthread.h>
5. #include <queue>
6. #define NUM 10
8. class ThreadPool{
9.     private:
10.         int num;
11.         std::queue<TASK> TaskQueue;
12.         pthread_mutex_t lock;
13.         pthread_cond_t cond;
14.         ThreadPool(int _num = NUM):num(_num){
15.             pthread_mutex_init(&lock,nullptr);
16.             pthread_cond_init(&cond,nullptr);
17.         }
18.         ThreadPool(const ThreadPool& TP){}
19.         ~ThreadPool(){
20.             pthread_mutex_destroy(&lock);
21.             pthread_cond_destroy(&cond);
22.         }
23.         static ThreadPool* tp;
24.     public:
26.         static ThreadPool* GetInstance(int _num = NUM){
27.            static pthread_mutex_t t = PTHREAD_MUTEX_INITIALIZER;
28.             if(tp == nullptr){
29.                 pthread_mutex_lock(&t);
30.                 if(tp == nullptr){
31.                     tp = new ThreadPool(_num);
32.                     tp->InitThreadPool();
33.                 }
34.                 pthread_mutex_unlock(&t);
35.             }
36.             return tp;
37.         }
39.         static void* ThreadRoutine(void* arg){
40.             ThreadPool* tp = (ThreadPool*)arg;
41.             while(true){
42.                 TASK task;
43.                 tp->Lock();
44.                 while(tp->IsEmpty()){
45.                     tp->ThreadWait();
46.                 }
47.                 tp->PopTask(task);
48.                 tp->Unlock();
49.                 task.ProcessOn();
50.             }
51.         }
52.         bool InitThreadPool(){
53.             for(int i = 0; i< num;i++){
54.                 pthread_t tid;
55.                 if(0 != pthread_create(&tid,nullptr, ThreadRoutine,this)){
56.                     LOG(FATAL,"create pthread unsucess");
57.                     return false;
58.                 }
59.             }
60.             return true;
61.         }
62.         void Lock(){
63.             pthread_mutex_lock(&lock);
64.         }
65.         void Unlock(){
66.             pthread_mutex_unlock(&lock);
67.         }
68.         void ThreadWait(){
69.             pthread_cond_wait(&cond,&lock);
70.         }
71.         void ThreadWakeup(){
72.             pthread_cond_signal(&cond);
73.         }
74.         bool IsEmpty(){
75.             return TaskQueue.size() == 0 ? true:false;
76.         }
77.         void PushTask(const TASK& task){
78.             Lock();
79.             TaskQueue.push(task);
80.             Unlock();                             
81.             ThreadWakeup();
82.             //Routine函数中cond_wait用while循环判断主要是解锁和唤醒代码的顺序问题
83.             //如果先解锁,那么就会有其他进程抢到锁开始执行后续,但不一定是等待进程在执行
84.             //所以当后面唤醒等待进程时候,可能会发现任务队列仍然为空,但却继续往下执行,这不符合我们的逻辑
85.         }
86.         void PopTask(TASK& task){
87.             task = TaskQueue.front();
88.             TaskQueue.pop();
89.         }
90. };
91. ThreadPool* ThreadPool::tp = nullptr;

复制代码

3、项目总结

   聚焦于处理HTTP的哀求和构建对应响应; 我们紧张研究基于 HTTP/1.0 短连接 的GET和POST方法;获得哀求，分析哀求，错误处理等; 制定特定的网页src用于返回; 引入简单的日志体系
  搭建CGI机制;父子管道，计划dup2重定向，情况变量传参等
  引入线程池;接纳多线程技能，缓解内存开销.

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