简单web服务器的实现（C++）【转载】

一、具体功能实现

  • GET方法请求解析
  • POST方法请求解析
  • 返回请求资源页面
  • 利用GET方法实现加减法
  • 利用POST方法实现加减法
  • HTTP请求行具体解析
  • 400、403、404错误码返回的处理

二、什么是web服务器

  • web服务器就是在物理服务器基础上的具有服务端功能的网络连接程序，简而言之就是处理客户端发来的各种请求然后根据服务器的逻辑处理返回一个结果给客户端。在web服务器和客户端之间的通信是基于HTTP协议进行的。而客户端可以是浏览器也可以是支持HTTP协议的APP。
  • 那么浏览器应该怎么连接上自己的web服务器呢，最简单的web服务器就是通过TCP三次握手建立连接后，服务器直接返回一个结果给浏览器。浏览器和服务器是通过TCP三路握手建立连接的。浏览器在通过URL（统一资源定位符，就是我们俗称的网络地址）去请求服务器的连接，并且通过URL中的路径请求服务器上的资源。举个栗子就是这样的：

最简单的web服务器：

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<sys/socket.h>
  4. #include<sys/types.h>
  5. #include<sys/stat.h>
  6. #include<sys/sendfile.h>
  7. #include<fcntl.h>
  8. #include<netinet/in.h>
  9. #include<arpa/inet.h>
  10. #include<assert.h>
  11. #include<unistd.h>
  12. #include<string.h>
  13. const int port = 8888;
  14. int main(int argc,char *argv[])
  15. {
  16.     if(argc<0)
  17.     {
  18.         printf("need two canshu\n");
  19.         return 1;
  20.     }
  21.     int sock;
  22.     int connfd;
  23.     struct sockaddr_in sever_address;
  24.     bzero(&sever_address,sizeof(sever_address));
  25.     sever_address.sin_family = PF_INET;
  26.     sever_address.sin_addr.s_addr = htons(INADDR_ANY);
  27.     sever_address.sin_port = htons(8888);
  28.  
  29.     sock = socket(AF_INET,SOCK_STREAM,0);
  30.  
  31.     assert(sock>=0);
  32.  
  33.     int ret = bind(sock, (struct sockaddr*)&sever_address,sizeof(sever_address));
  34.     assert(ret != -1);
  35.  
  36.     ret = listen(sock,1);
  37.     assert(ret != -1);
  38.     while(1)
  39.     {
  40.         struct sockaddr_in client;
  41.         socklen_t client_addrlength = sizeof(client);
  42.         connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
  43.         if(connfd<0)
  44.         {
  45.             printf("errno\n");
  46.         }
  47.         else{
  48.                 char request[1024];
  49.                 recv(connfd,request,1024,0);
  50.                 request[strlen(request)+1]='\0';
  51.                 printf("%s\n",request);
  52.                 printf("successeful!\n");
  53.                 char buf[520]="HTTP/1.1 200 ok\r\nconnection: close\r\n\r\n";//HTTP响应
  54.                 int s = send(connfd,buf,strlen(buf),0);//发送响应
  55.                 //printf("send=%d\n",s);
  56.                 int fd = open("hello.html",O_RDONLY);//消息体
  57.                 sendfile(connfd,fd,NULL,2500);//零拷贝发送消息体
  58.                 close(fd);
  59.                 close(connfd);
  60.         }
  61.     }
  62.     return 0;
  63. }

最简单的html文件：

  1. <html>
  2.     <body bgcolor="blue">
  3.      this is the html.
  4.      <hr>
  5.      <p>hello word! waste young! </p><br>
  6.     </body>
  7. </html>

 

运行web.c文件，生成执行文件a.out，在终端执行后，我们在浏览器的网址栏中输入：http://localhost:8888 然后确认后，就会返回hello.html的文件页面

这里的URL，localhost:实际就是hostname，然后8888是端口，如果在端口后面再加上比如/hello.html这样的路径就表示请求服务器上的一个hello.html，这里请求方法是GET，所以要求服务器返回该资源的页面。

那么此时再来看下服务器接收到的东西，就是HTTP请求。

第一行就是请求行，请求行的格式是这样的：请求方法+空格+URL+空格+协议版本+\r+\n 这里的请求方法是GET ，URL是/(在这里，URL就相当于资源的路径，若在网址栏输入的是http://localhost:8888/hello.html的话，这里浏览器发送过来的URL就是/hello.html)，协议版本是HTTP/1.1（现在多数协议版本都是这个）。

第二行到最后一行都是请求头部，请求头部的格式是这样的： 头部字段：+空格+数值+\r+\n 然后多个头部子段组织起来就是请求头部，在最后的头部字段的格式中需要有两个换行符号，最后一行的格式是：头部字段：+空格+数值+\r+\n+\r+\n 因为在后面还要跟着请求数据，为了区分请求数据和请求头的结束，就多了一个换行符。

三、HTTP请求和响应

（1）HTTP请求

简而言之就是客户端发送给服务端的请求。请求格式上面略提到了一点点，大概的格式就如下所示：

其中的细节就很多了，但是主要的是请求方法。其中头部字段有很多，大家可以上网百度。主要实现的就是GET方法和POST方法，其中GET方法是请求资源，但是不改变服务器上资源的，POST方法的话就会请求更改服务器上的资源。除了这两个方法外，还有PUT，DELETE，HEAD，TRACE等等。对应增删查改的就是PUT、DELETE、POST、GET。

然后URL就是要请求的资源路径，协议版本为HTTP/1.1，头部字段根据每个头部字段名都代表着给服务器的一个信息，具体可以根据以下网址查看：https://blog.csdn.net/sinat_22840937/article/details/64438253

（2）HTTP响应

HTTP响应就是服务端返回给客户端的响应消息。响应格式大概如下：

其中响应首行格式如：HTTP/1.1+状态响应码+\r\n 状态响应码参考如下：https://baike.baidu.com/item/HTTP状态码/5053660?fr=aladdin

这里大概用的是200，400，403，404，其中头部字段需要注意content-length，在服务器中响应码若没有消息题的长度，浏览器就只能通过关闭客户端才可以得知消息体的长度，才可以显示出消息体的具体表现。而且消息体的长度必须要和消息体吻合。如果服务端发送的消息体长度不正确的话，会导致超时或者浏览器一直显示不了要的资源文件。详细可以参考博客：https://www.cnblogs.com/lovelacelee/p/5385683.html

四、如何写出小型 web服务器

1、代码预备知识

  • 了解TCP三次握手和TCP四次挥手
  • 线程同步机制包装类
  • 线程池创建
  • epoll多路复用

（1）TCP三次握手

  1. 服务器需要准备好接受外来连接，通过socket bind listen三个函数完成，然后我们称为被动打开。
  2. 客户则通过connect发起主动连接请求，这就导致客户TCP发送一个SYN（同步）分节去告诉服务器客户将在待建立的连接中发送的数据的初始序列号，通常SYN不携带数据，其所在IP数据只有一个IP首部，一个TCP首部以及可能有的TCP选项。
  3. 服务器确认客户的SYN后，同时自己也要发送一个SYN分节，它含有服务器将在同一个连接中发送的数据的初始化列序号，服务器在单个分节中发送SYN和对客户SYN的确认
  4. 客户必须去确认服务器的SYN

 

（2）TCP四次挥手

  1. 某一个应用进程首先调用close，称为该端执行主动关闭，该端的TCP会发送一个FIN分节，表示数据已经发送完毕
  2. 接到FIN的对端将执行被动关闭，这个FIN由TCP确认，它的接受也作为一个文件结束符传递给接收端应用进程（放在已排队等候该应用进程接收的任何其他数据之后），因为FIN的接收意味着接收端应用进程在相应连接上已无额外数据可以接收
  3. 一段时间后，接收到这个文件结束符的应用进程会调用close关闭它的套接字，这会导致它的TCP也要发送一个FIN
  4. 接收这个最终FIN的原发送端TCP（即执行主动关闭的那一端）确认这个FIN

参考网站：https://www.cnblogs.com/Andya/p/7272462.html

 （3）线程池的创建

我用的是半同步／半反应堆线程池。该线程池通用性比较高，主线程一般往工作队列中加入任务，然后工作线程等待后并通过竞争关系从工作队列中取出任务并且执行。而且应用到服务器程序中的话要保证客户请求都是无状态的，因为同一个连接上的不同请求可能会由不同的线程处理。

ps:若工作队列为空，则线程就处于等待状态，就需要同步机制的处理。 

代码：

  1.  
  2. #ifndef _THREADPOOL_H
  3. #define _THREADPOOL_H
  4. #include<iostream>
  5. #include<list>
  6. #include<cstdio>
  7. #include<semaphore.h>
  8. #include<exception>
  9. #include<pthread.h>
  10. #include"myhttp_coon.h"
  11. #include"mylock.h"
  12. using namespace std;
  13.  
  14. template<typename T>
  15. /*线程池的封装*/
  16. class threadpool
  17. {
  18. private:
  19.     int max_thread;//线程池中的最大线程总数
  20.     int max_job;//工作队列的最大总数
  21.     pthread_t *pthread_poll;//线程池数组
  22.     std::list<T*> m_myworkqueue;//请求队列
  23.     mylocker m_queuelocker;//保护请求队列的互斥锁
  24.     sem m_queuestat;//由信号量来判断是否有任务需要处理
  25.     bool m_stop;;//是否结束线程
  26. public:
  27.     threadpool();
  28.     ~threadpool();
  29.     bool addjob(T* request);
  30. private:
  31.     static void* worker(void *arg);
  32.     void run();
  33. };
  34. /*线程池的创建*/
  35. template <typename T>
  36. threadpool<T> :: threadpool()
  37. {
  38.     max_thread = 8;
  39.     max_job = 1000;
  40.     m_stop = false;
  41.     pthread_poll = new pthread_t[max_thread];//为线程池开辟空间
  42.     if(!pthread_poll)
  43.     {
  44.         throw std::exception();
  45.     }
  46.     for(int i=0; i<max_thread; i++)
  47.     {
  48.         cout << "Create the pthread:" << i << endl;
  49.         if(pthread_create(pthread_poll+i, NULL, worker, this)!=0)
  50.         {
  51.             delete [] pthread_poll;
  52.             throw std::exception();
  53.         }
  54.         if(pthread_detach(pthread_poll[i]))//将线程分离
  55.         {
  56.             delete [] pthread_poll;
  57.             throw std::exception();
  58.         }
  59.     }
  60. }
  61.  
  62. template <typename T>
  63. threadpool<T>::~threadpool()
  64. {
  65.     delete[] pthread_poll;
  66.     m_stop = true;
  67. }
  68.  
  69. template <typename T>
  70. bool threadpool<T>::addjob(T* request)
  71. {
  72.     m_queuelocker.lock();
  73.     if(m_myworkqueue.size()> max_job)//如果请求队列大于了最大请求队列，则出错
  74.     {
  75.         m_queuelocker.unlock();
  76.         return false;
  77.     }
  78.     m_myworkqueue.push_back(request);//将请求加入到请求队列中
  79.     m_queuelocker.unlock();
  80.     m_queuestat.post();//将信号量增加1
  81.     return true;
  82. }
  83. template <typename T>
  84. void* threadpool<T>::worker(void *arg)
  85. {
  86.     threadpool *pool = (threadpool*)arg;
  87.     pool->run();
  88.     return pool;
  89. }
  90.  
  91. template <typename T>
  92. void threadpool<T> :: run()
  93. {
  94.     while(!m_stop)
  95.     {
  96.         m_queuestat.wait();//信号量减1，直到为0的时候线程挂起等待
  97.         m_queuelocker.lock();
  98.         if(m_myworkqueue.empty())
  99.         {
  100.             m_queuelocker.unlock();
  101.             continue;
  102.         }
  103.         T* request = m_myworkqueue.front();
  104.         m_myworkqueue.pop_front();
  105.         m_queuelocker.unlock();
  106.         if(!request)
  107.         {
  108.             continue;
  109.         }
  110.         request->doit();//执行工作队列
  111.     }
  112. }
  113. #endif

 

（4）同步机制的包装类

因为采用了线程池，就相当于用了多线程编程，此时就需要考虑各个线程对公共资源的访问的限制，因为方便之后的代码采用了三种包装机制，分别是信号量的类，互斥锁的类和条件变量的类。在服务器中我使用的是信号量的类。其中信号量的原理和System V IPC信号量一样（不抄书了，直接拍照了。。。）

代码实现：

  1. #ifndef _MYLOCK_H
  2. #define _MYLOCK_H
  3. #include<iostream>
  4. #include<list>
  5. #include<cstdio>
  6. #include<semaphore.h>
  7. #include<exception>
  8. #include<pthread.h>
  9. #include"myhttp_coon.h"
  10. using namespace std;
  11.  
  12. /*封装信号量*/
  13. class sem{
  14. private:
  15.     sem_t m_sem;
  16. public:
  17.     sem();
  18.     ~sem();
  19.     bool wait();//等待信号量
  20.     bool post();//增加信号量
  21. };
  22. //创建信号量
  23. sem :: sem()
  24. {
  25.     if(sem_init(&m_sem,0,0) != 0)
  26.     {
  27.         throw std ::exception();
  28.     }
  29. }
  30. //销毁信号量
  31. sem :: ~sem()
  32. {
  33.     sem_destroy(&m_sem);
  34. }
  35. //等待信号量
  36. bool sem::wait()
  37. {
  38.     return sem_wait(&m_sem) == 0;
  39. }
  40. //增加信号量
  41. bool sem::post()
  42. {
  43.     return sem_post(&m_sem) == 0;
  44. }
  45.  
  46. /*封装互斥锁*/
  47. class mylocker{
  48. private:
  49.     pthread_mutex_t m_mutex;
  50. public:
  51.     mylocker();
  52.     ~mylocker();
  53.     bool lock();
  54.     bool unlock();
  55. };
  56.  
  57. mylocker::mylocker()
  58. {
  59.     if(pthread_mutex_init(&m_mutex, NULL) != 0)
  60.     {
  61.         throw std::exception();
  62.     }
  63. }
  64.  
  65. mylocker::~mylocker()
  66. {
  67.     pthread_mutex_destroy(&m_mutex);
  68. }
  69. /*上锁*/
  70. bool mylocker::lock()
  71. {
  72.     return pthread_mutex_lock(&m_mutex)==0;
  73. }
  74. /*解除锁*/
  75. bool mylocker::unlock()
  76. {
  77.     return pthread_mutex_unlock(&m_mutex) == 0;
  78. }
  79.  
  80. /*封装条件变量*/
  81. class mycond{
  82. private:
  83.     pthread_mutex_t m_mutex;
  84.     pthread_cond_t m_cond;
  85. public:
  86.     mycond();
  87.     ~mycond();
  88.     bool wait();
  89.     bool signal();
  90. };
  91.  
  92. mycond::mycond()
  93. {
  94.     if(pthread_mutex_init(&m_mutex,NULL)!=0)
  95.     {
  96.         throw std::exception();
  97.     }
  98.     if(pthread_cond_init(&m_cond, NULL)!=0)
  99.     {
  100.         throw std::exception();
  101.     }
  102. }
  103.  
  104. mycond::~mycond()
  105. {
  106.     pthread_mutex_destroy(&m_mutex);
  107.     pthread_cond_destroy(&m_cond);
  108. }
  109.  
  110. /*等待条件变量*/
  111. bool mycond::wait()
  112. {
  113.     int ret;
  114.     pthread_mutex_lock(&m_mutex);
  115.     ret = pthread_cond_wait(&m_cond,&m_mutex);
  116.     pthread_mutex_unlock(&m_mutex);
  117.     return ret == 0;
  118. }
  119.  
  120. /*唤醒等待条件变量的线程*/
  121. bool mycond::signal()
  122. {
  123.     return pthread_cond_signal(&m_cond) == 0;
  124. }
  125.  
  126. #endif

（5）epoll多路复用 

 epoll系列系统调用函数(#include<sys/epoll.h>):

int epoll_create(int size);创建内核事件表

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);操作epoll的内核事件表

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);一段时间内等待一组文件描述符上的就绪事件

除此这些函数外，还需要了解epoll的LT模式和ET模式还有EPOLLONESHOT事件.

下面三篇博客了解下：👇

https://blog.csdn.net/davidsguo008/article/details/73556811

https://blog.csdn.net/men_wen/article/details/53456491

https://blog.csdn.net/yusiguyuan/article/details/15027821

代码：

  1. #include<iostream>
  2. #include<unistd.h>
  3. #include<sys/socket.h>
  4. #include<netinet/in.h>
  5. #include<arpa/inet.h>
  6. #include<stdio.h>
  7. #include<errno.h>
  8. #include<string.h>
  9. #include<fcntl.h>
  10. #include<stdlib.h>
  11. #include<assert.h>
  12. #include<sys/epoll.h>
  13. #include"threadpool.h"
  14. //#include"myhttp_coon.h"
  15. using namespace std;
  16. const int port = 8888;
  17.  
  18. int setnonblocking(int fd)
  19. {
  20.     int old_option = fcntl(fd, F_GETFL);
  21.     int new_option = old_option | O_NONBLOCK;
  22.     fcntl(fd, F_SETFL, new_option);
  23.     return old_option;
  24. }
  25.  
  26. void addfd(int epfd, int fd, bool flag)
  27. {
  28.     epoll_event ev;
  29.     ev.data.fd = fd;
  30.     ev.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
  31.     if(flag)
  32.     {
  33.         ev.events = ev.events | EPOLLONESHOT;
  34.     }
  35.     epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
  36.     setnonblocking(fd);
  37. }
  38.  
  39. int main(int argc, char *argv[])
  40. {
  41.     threadpool<http_coon>* pool = NULL;
  42.     pool = new threadpool<http_coon>;
  43.     http_coon* users = new http_coon[100];
  44.     assert(users);
  45.     struct sockaddr_in address;
  46.     bzero(&address, sizeof(address));
  47.     address.sin_family = AF_INET;
  48.     address.sin_port = htons(port);
  49.     address.sin_addr.s_addr = htons(INADDR_ANY);
  50.  
  51.     int listenfd = socket(AF_INET,SOCK_STREAM,0);
  52.     assert(listenfd >= 0);
  53.  
  54.     int ret;
  55.     ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
  56.     assert(ret != -1);
  57.  
  58.     ret = listen(listenfd,5);
  59.     assert(ret >= 0);
  60.  
  61.     int epfd;
  62.     epoll_event events[1000];
  63.     epfd = epoll_create(5);
  64.     assert(epfd != -1);
  65.     addfd(epfd, listenfd, false);//listen不能注册EPOLLONESHOT事件，否则只能处理一个客户连接
  66.     while(true)
  67.     {
  68.         int number = epoll_wait(epfd, events, 1000, -1);
  69.         if( (number < 0) && (errno != EINTR) )
  70.         {
  71.             printf("my epoll is failure!\n");
  72.             break;
  73.         }
  74.         for(int i=0; i<number; i++)
  75.         {
  76.             int sockfd = events[i].data.fd;
  77.             if(sockfd == listenfd)//有新用户连接
  78.             {
  79.                 struct sockaddr_in client_address;
  80.                 socklen_t client_addresslength = sizeof(client_address);
  81.                 int client_fd = accept(listenfd,(struct sockaddr*)&client_address, &client_addresslength);
  82.                 if(client_fd < 0)
  83.                 {
  84.                     printf("errno is %d\n",errno);
  85.                     continue;
  86.                 }
  87.                 /*如果连接用户超过了预定于的用户总数，则抛出异常*/
  88.                /* if(http_coon::m_user_count > MAX_FD)
  89.                 {
  90.                     show_error(client_fd, "Internal sever busy");
  91.                     continue;
  92.                 }*/
  93.                 //初始化客户连接
  94.                 cout << epfd << " " << client_fd << endl;
  95.                 addfd(epfd, client_fd, true);
  96.                 cout << "client_fd:" << client_fd << "****\n";
  97.                 users[client_fd].init(epfd,client_fd);
  98.             }
  99.             else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR))
  100.             {
  101.                 /*出现异常则关闭客户端连接*/
  102.                 users[sockfd].close_coon();
  103.             }
  104.             else if(events[i].events & EPOLLIN)//可以读取
  105.             {
  106.                 
  107.                 if(users[sockfd].myread())
  108.                 {
  109.                     
  110.                     /*读取成功则添加任务队列*/
  111.                     pool->addjob(users+sockfd);
  112.                 }
  113.                 else{
  114.                     users[sockfd].close_coon();
  115.                 }
  116.             }
  117.             else if(events[i].events & EPOLLOUT)//可写入
  118.             {
  119.                 if(!users[sockfd].mywrite())
  120.                 {
  121.                     users[sockfd].close_coon();
  122.                 }
  123.             }
  124.         }
  125.     }
  126.     close(epfd);
  127.     close(listenfd);
  128.     delete[] users;
  129.     delete pool;
  130.     return 0;
  131.     
  132. }

 

2、主要逻辑思路

  1. 首先创建和客户端的连接
  2. 服务器通过客户端的HTTP请求解析来判断返回何种结果.HTTP解析是以行为单位的，前提条件是根据\r\n来判断是否完整度入一行，若完整读入一行了那么就可以进行解析了。
  3. 通过HTTP请求的解析后，在写缓冲区写如HTTP响应，发送给客户端（HTTP应答包括一个状态行，多个头部字段，一个空行和资源内容，其中前三个部分的内容一般会被web服务器放置在一块内存中，而文档的内容通常会被放到另一个单独的内存中）
  4. 发送响应首行后，就可以发送主要的消息体了

主要就是封装在myhttp_coon.h中：

  1.  
  2. #ifndef _MYHTTP_COON_H
  3. #define _MYHTTP_COON_H
  4. #include<iostream>
  5. #include<stdio.h>
  6. #include<string.h>
  7. #include<sys/wait.h>
  8. #include<sys/socket.h>
  9. #include<errno.h>
  10. #include<stdlib.h>
  11. #include<unistd.h>
  12. #include<assert.h>
  13. #include<sys/sendfile.h>
  14. #include<sys/epoll.h>
  15. #include<sys/fcntl.h>
  16. #include<sys/stat.h>
  17. #include<sys/types.h>
  18. using namespace std;
  19. #define READ_BUF 2000
  20. class http_coon{
  21. public:
  22.     /*NO_REQUESTION是代表请求不完整，需要客户继续输入；BAD_REQUESTION是HTTP请求语法不正确；GET_REQUESTION代表获得并且解析了一个正确的HTTP请求；FORBIDDEN_REQUESTION是代表访问资源的权限有问题；FILE_REQUESTION代表GET方法资源请求；INTERNAL_ERROR代表服务器自身问题；NOT_FOUND代表请求的资源文件不存在；DYNAMIC_FILE表示是一个动态请求；POST_FILE表示获得一个以POST方式请求的HTTP请求*/
  23.     enum HTTP_CODE{NO_REQUESTION, GET_REQUESTION, BAD_REQUESTION, FORBIDDEN_REQUESTION,FILE_REQUESTION,INTERNAL_ERROR,NOT_FOUND,DYNAMIC_FILE,POST_FILE};
  24.     /*HTTP请求解析的状态转移。HEAD表示解析头部信息，REQUESTION表示解析请求行*/
  25.     enum CHECK_STATUS{HEAD,REQUESTION};
  26. private:
  27.     char requst_head_buf[1000];//响应头的填充
  28.     char post_buf[1000];//Post请求的读缓冲区
  29.     char read_buf[READ_BUF];//客户端的http请求读取
  30.     char filename[250];//文件总目录
  31.     int file_size;//文件大小
  32.     int check_index;//目前检测到的位置
  33.     int read_buf_len;//读取缓冲区的大小
  34.     char *method;//请求方法
  35.     char *url;//文件名称
  36.     char *version;//协议版本
  37.     char *argv;//动态请求参数
  38.     bool m_linger;//是否保持连接
  39.     int m_http_count;//http长度
  40.     char *m_host;//主机名记录
  41.     char path_400[17];//出错码400打开的文件名缓冲区
  42.     char path_403[23];//出错码403打开返回的文件名缓冲区
  43.     char path_404[40];//出错码404对应文件名缓冲区
  44.     char message[1000];//响应消息体缓冲区
  45.     char body[2000];//post响应消息体缓冲区
  46.     CHECK_STATUS status;//状态转移
  47.     bool m_flag;//true表示是动态请求，反之是静态请求
  48. public:
  49.     int epfd;
  50.     int client_fd;
  51.     int read_count;
  52.     http_coon();
  53.     ~http_coon();
  54.     void init(int e_fd, int c_fd);//初始化
  55.     int myread();//读取请求
  56.     bool mywrite();//响应发送
  57.     void doit();//线程接口函数
  58.     void close_coon();//关闭客户端链接
  59. private:
  60.     HTTP_CODE analyse();//解析Http请求头的函数
  61.     int jude_line(int &check_index, int &read_buf_len);//该请求是否是完整的以行\r\n
  62.     HTTP_CODE head_analyse(char *temp);//http请求头解析
  63.     HTTP_CODE requestion_analyse(char *temp);//http请求行解析
  64.     HTTP_CODE do_post();//对post请求中的参数进行解析
  65.     HTTP_CODE do_file();//对GET请求方法中的url 协议版本的分离
  66.     void modfd(int epfd, int sock, int ev);//改变socket为状态
  67.     void dynamic(char *filename, char *argv);//通过get方法进入的动态请求处理
  68.     void post_respond();//POST请求响应填充
  69.     bool bad_respond();//语法错误请求响应填充
  70.     bool forbiden_respond();//资源权限限制请求响应的填充
  71.     bool succeessful_respond();//解析成功请求响应填充
  72.     bool not_found_request();//资源不存在请求响应填充
  73. };
  74.  
  75. void http_coon::init(int e_fd, int c_fd)
  76. {
  77.     epfd = e_fd;
  78.     client_fd = c_fd;
  79.     read_count = 0;
  80.     m_flag = false;
  81. }
  82.  
  83. http_coon::http_coon()
  84. {
  85.     
  86. }
  87.  
  88. http_coon::~http_coon()
  89. {
  90.  
  91. }
  92. /*关闭客户端链接*/
  93. void http_coon::close_coon()
  94. {
  95.     epoll_ctl(epfd, EPOLL_CTL_DEL, client_fd, 0);
  96.     close(client_fd);
  97.     client_fd = -1;
  98.  
  99. }
  100. /*改变事件表中的事件属性*/
  101. void http_coon::modfd(int epfd, int client_fd, int ev)
  102. {
  103.     epoll_event event;
  104.     event.data.fd = client_fd;
  105.     event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLRDHUP;
  106.     epoll_ctl(epfd, EPOLL_CTL_MOD, client_fd, &event);
  107.     
  108. }
  109. /*read函数的封装*/
  110. int http_coon::myread()
  111. {
  112.     bzero(&read_buf,sizeof(read_buf));
  113.     while(true)
  114.     {
  115.         int ret = recv(client_fd, read_buf+read_count, READ_BUF-read_count, 0 );
  116.         if(ret == -1)
  117.         {
  118.             if(errno == EAGAIN || errno == EWOULDBLOCK)//读取结束
  119.             {
  120.                 break;
  121.             }
  122.             return 0;
  123.         }
  124.         else if(ret == 0)
  125.         {
  126.             return 0;
  127.         }
  128.         read_count = read_count + ret;
  129.     }
  130.     strcpy(post_buf,read_buf);
  131.     return 1;
  132. }
  133. /*响应状态的填充，这里返回可以不为bool类型*/
  134. bool http_coon::succeessful_respond()//200
  135. {
  136.     m_flag = false;
  137.     bzero(requst_head_buf,sizeof(requst_head_buf));
  138.     sprintf(requst_head_buf,"HTTP/1.1 200 ok\r\nConnection: close\r\ncontent-length:%d\r\n\r\n",file_size);
  139. }
  140. bool http_coon::bad_respond()//400
  141. {
  142.     bzero(url, strlen(url));
  143.     strcpy(path_400,"bad_respond.html");
  144.     url = path_400;
  145.     bzero(filename,sizeof(filename));
  146.     sprintf(filename,"/home/jialuhu/linux_net/web_sever/%s",url);
  147.     struct stat my_file;
  148.     if(stat(filename,&my_file)<0)
  149.     {
  150.         cout << "文件不存在\n";
  151.     }
  152.     file_size = my_file.st_size;
  153.     bzero(requst_head_buf,sizeof(requst_head_buf));
  154.     sprintf(requst_head_buf,"HTTP/1.1 400 BAD_REQUESTION\r\nConnection: close\r\ncontent-length:%d\r\n\r\n",file_size);
  155. }
  156. bool http_coon::forbiden_respond()//403
  157. {
  158.     bzero(url, strlen(url));
  159.     strcpy(path_403,"forbidden_request.html");
  160.     url = path_403;
  161.     bzero(filename,sizeof(filename));
  162.     sprintf(filename,"/home/jialuhu/linux_net/web_sever/%s",url);
  163.     struct stat my_file;
  164.     if(stat(filename,&my_file)<0)
  165.     {
  166.         cout << "失败\n";
  167.     }
  168.     file_size = my_file.st_size;
  169.     bzero(requst_head_buf,sizeof(requst_head_buf));
  170.     sprintf(requst_head_buf,"HTTP/1.1 403 FORBIDDEN\r\nConnection: close\r\ncontent-length:%d\r\n\r\n",file_size);
  171. }
  172. bool http_coon::not_found_request()//404
  173. {
  174.     bzero(url, strlen(url));
  175.     strcpy(path_404,"not_found_request.html");
  176.     url = path_404;
  177.     bzero(filename,sizeof(filename));
  178.     sprintf(filename,"/home/jialuhu/linux_net/web_sever/%s",url);
  179.     struct stat my_file;
  180.     if(stat(filename,&my_file)<0)
  181.     {
  182.         cout << "草拟\n";
  183.     }
  184.     file_size = my_file.st_size;
  185.     bzero(requst_head_buf,sizeof(requst_head_buf));
  186.     sprintf(requst_head_buf,"HTTP/1.1 404 NOT_FOUND\r\nConnection: close\r\ncontent-length:%d\r\n\r\n",file_size);
  187. }
  188.  
  189. /*动态请求处理*/
  190. void http_coon::dynamic(char *filename, char *argv)
  191. {
  192.     int len = strlen(argv);
  193.     int k = 0;
  194.     int number[2];
  195.     int sum=0;
  196.     m_flag = true;
  197.     bzero(requst_head_buf,sizeof(requst_head_buf));
  198.     sscanf(argv,"a=%d&b=%d",&number[0],&number[1]);
  199.     if(strcmp(filename,"/add")==0)
  200.     {
  201.         sum = number[0] + number[1];
  202.         sprintf(body,"<html><body>\r\n<p>%d + %d = %d </p><hr>\r\n</body></html>\r\n",number[0],number[1],sum);
  203.         sprintf(requst_head_buf,"HTTP/1.1 200 ok\r\nConnection: close\r\ncontent-length: %d\r\n\r\n",strlen(body));
  204.     }
  205.     else if(strcmp(filename,"/multiplication")==0)
  206.     {
  207.         cout << "\t\t\t\tmultiplication\n\n";
  208.         sum = number[0]*number[1];
  209.         sprintf(body,"<html><body>\r\n<p>%d * %d = %d </p><hr>\r\n</body></html>\r\n",number[0],number[1],sum);
  210.         sprintf(requst_head_buf,"HTTP/1.1 200 ok\r\nConnection: close\r\ncontent-length: %d\r\n\r\n",strlen(body));
  211.     }
  212. }
  213. /*POST请求处理*/
  214. void http_coon::post_respond()
  215. {
  216.     if(fork()==0)
  217.     {
  218.         dup2(client_fd,STDOUT_FILENO);
  219.         execl(filename,argv,NULL);
  220.     }
  221.     wait(NULL);
  222. }
  223.  
  224. /*判断一行是否读取完整*/
  225. int http_coon::jude_line(int &check_index, int &read_buf_len)
  226. {
  227.     cout << read_buf << endl;
  228.     char ch;
  229.     for( ; check_index<read_buf_len; check_index++)
  230.     {
  231.         ch = read_buf[check_index];
  232.         if(ch == '\r' && check_index+1<read_buf_len && read_buf[check_index+1]=='\n')
  233.         {
  234.             read_buf[check_index++] = '\0';
  235.             read_buf[check_index++] = '\0';
  236.             return 1;//完整读入一行
  237.         }
  238.         if(ch == '\r' && check_index+1==read_buf_len)
  239.         {
  240.             return 0;
  241.         }
  242.         if(ch == '\n')
  243.         {
  244.             if(check_index>1 && read_buf[check_index-1]=='\r')
  245.             {
  246.                 read_buf[check_index-1] = '\0';
  247.                 read_buf[check_index++] = '\0';
  248.                 return 1;
  249.             }
  250.             else{
  251.                 return 0;
  252.             }
  253.         }
  254.     }
  255.     return 0;
  256. }
  257.  
  258. /*解析请求行*/
  259. http_coon::HTTP_CODE http_coon::requestion_analyse(char *temp)
  260. {
  261.     char *p = temp;
  262.     cout << "p=" << p << endl;
  263.     for(int i=0; i<2; i++)
  264.     {
  265.         if(i==0)
  266.         {
  267.             method = p;//请求方法保存
  268.             int j = 0;
  269.             while((*p != ' ') && (*p != '\r'))
  270.             {
  271.                 p++;
  272.             }
  273.             p[0] = '\0';
  274.             p++;
  275.             cout << "method:" <<method << endl;
  276.           //  method++;
  277.         }
  278.         if(i==1)
  279.         {
  280.             url = p;//文件路径保存
  281.             while((*p != ' ') && (*p != '\r'))
  282.             {
  283.                 p++;
  284.             }
  285.             p[0] = '\0';
  286.             p++;
  287.             cout << "url:" << url << endl;
  288.         }
  289.     }
  290.     version = p;//请求协议保存
  291.     while(*p != '\r')
  292.     {
  293.         p++;
  294.     }
  295.     p[0] = '\0';
  296.     p++;
  297.     p[0] = '\0';
  298.     p++;
  299.     cout << version << endl;
  300.     if(strcmp(method,"GET")!=0&&strcmp(method,"POST")!=0)
  301.     {
  302.         return BAD_REQUESTION;
  303.     }
  304.     if(!url || url[0]!='/')
  305.     {
  306.         return BAD_REQUESTION;
  307.     }
  308.     if(strcmp(version,"HTTP/1.1")!=0)
  309.     {
  310.         return BAD_REQUESTION;
  311.     }
  312.     status = HEAD;//状态转移到解析头部
  313.     return NO_REQUESTION;//继续解析
  314. }
  315.  
  316. /*解析头部信息*/
  317. http_coon::HTTP_CODE http_coon::head_analyse(char *temp)
  318. {
  319.     if(temp[0]=='\0')
  320.     {
  321.         //获得一个完整http请求
  322.         return GET_REQUESTION;
  323.     }
  324.     //处理其他头部
  325.     else if(strncasecmp(temp,"Connection:", 11) == 0)
  326.     {
  327.         temp = temp+11;
  328.         while(*temp==' ')
  329.         {
  330.             temp++;
  331.         }
  332.         if(strcasecmp(temp, "keep-alive") == 0)
  333.         {
  334.             m_linger = true;
  335.         }
  336.     }
  337.     else if(strncasecmp(temp,"Content-Length:", 15)==0)
  338.     {
  339.        
  340.         temp = temp+15;
  341.         while(*temp==' ')
  342.         {
  343.             cout << *temp << endl;
  344.             temp++;
  345.         }
  346.         m_http_count = atol(temp);//content-length需要填充
  347.     }
  348.     else if(strncasecmp(temp,"Host:",5)==0)
  349.     {
  350.         temp = temp+5;
  351.         while(*temp==' ')
  352.         {
  353.             temp++;
  354.         }
  355.         m_host = temp;
  356.     }
  357.     else{
  358.         cout << "can't handle it's hand\n";
  359.     }
  360.     return NO_REQUESTION;
  361. }
  362.  
  363. http_coon::HTTP_CODE http_coon::do_file()//GET方法请求，对其请求行进行解析，存写资源路径
  364. {
  365.     char path[40]="/home/jialuhu/linux_net/web_sever";
  366.     char* ch;
  367.     if(ch=strchr(url,'?'))
  368.     {
  369.         argv = ch+1;
  370.         *ch = '\0';
  371.         strcpy(filename,url);
  372.         return DYNAMIC_FILE;
  373.     }
  374.     else{
  375.             strcpy(filename,path);
  376.             strcat(filename,url);
  377.             struct stat m_file_stat;
  378.             if(stat(filename, &m_file_stat) < 0)
  379.             {
  380.                 //cout << "打不开\n";
  381.                 return NOT_FOUND;//NOT_FOUND 404
  382.             }
  383.             if( !(m_file_stat.st_mode & S_IROTH))//FORBIDDEN_REQUESTION 403
  384.             {
  385.                 return FORBIDDEN_REQUESTION;
  386.             }
  387.             if(S_ISDIR(m_file_stat.st_mode))
  388.             {
  389.                 return BAD_REQUESTION;//BAD_REQUESTION 400
  390.             }
  391.             file_size = m_file_stat.st_size;
  392.             return FILE_REQUESTION;
  393.     }
  394. }
  395. http_coon::HTTP_CODE http_coon::do_post()//POST方法请求，分解并且存入参数
  396. {
  397.     int k = 0;
  398.     int star;
  399.     char path[34]="/home/jialuhu/linux_net/web_sever";
  400.     strcpy(filename,path);
  401.     strcat(filename,url);
  402.     star = read_buf_len-m_http_count;
  403.     argv = post_buf + star;
  404.     argv[strlen(argv)+1]='\0';
  405.     if(filename!=NULL && argv!=NULL)
  406.     {
  407.         return POST_FILE;
  408.     }
  409.     return BAD_REQUESTION;
  410. }
  411.  
  412. /*http请求解析*/
  413. http_coon::HTTP_CODE http_coon::analyse()
  414. {
  415.     status = REQUESTION;
  416.     int flag;
  417.     char *temp = read_buf;
  418.     int star_line = 0;
  419.     check_index = 0;
  420.     int star = 0;
  421.     read_buf_len = strlen(read_buf);
  422.     int len = read_buf_len;
  423.     while((flag=jude_line(check_index, len))==1)
  424.     {
  425.         temp = read_buf + star_line;
  426.         star_line = check_index;
  427.         switch(status)
  428.         {
  429.             case REQUESTION://请求行分析，包括文件名称和请求方法
  430.             {
  431.                 cout << "requestion\n";
  432.                 int ret;
  433.                 ret = requestion_analyse(temp);
  434.                 if(ret==BAD_REQUESTION)
  435.                 {
  436.                     cout << "ret == BAD_REQUESTION\n";
  437.                     //请求格式不正确
  438.                     return BAD_REQUESTION;
  439.                 }
  440.                 break;
  441.             }
  442.             case HEAD://请求头的分析
  443.             {
  444.                 int ret;
  445.                 ret = head_analyse(temp);
  446.                 if(ret==GET_REQUESTION)//获取完整的HTTP请求
  447.                 {
  448.                     if(strcmp(method,"GET")==0)
  449.                     {
  450.                         return do_file();//GET请求文件名分离函数     
  451.                     }
  452.                     else if(strcmp(method,"POST")==0)
  453.                     {
  454.                         return do_post();//POST请求参数分离函数
  455.                     }
  456.                     else{
  457.                         return BAD_REQUESTION;
  458.                     }
  459.                 }
  460.                 break;
  461.             }
  462.             default:
  463.             {
  464.                 return INTERNAL_ERROR;
  465.             }
  466.         }
  467.     }
  468.     return NO_REQUESTION;//请求不完整，需要继续读入
  469. }
  470.  
  471.  
  472.  
  473. /*线程取出工作任务的接口函数*/
  474. void http_coon::doit()
  475. {
  476.     int choice = analyse();//根据解析请求头的结果做选择
  477.     switch(choice)
  478.     {
  479.         case NO_REQUESTION://请求不完整
  480.         {
  481.             cout << "NO_REQUESTION\n";
  482.             /*改变epoll的属性*/
  483.             modfd(epfd, client_fd, EPOLLIN);
  484.             return;
  485.         }
  486.         case BAD_REQUESTION: //400
  487.         {
  488.             cout << "BAD_REQUESTION\n";
  489.             bad_respond();
  490.             modfd(epfd, client_fd, EPOLLOUT);
  491.             break;
  492.         }
  493.         case FORBIDDEN_REQUESTION://403
  494.         {
  495.             cout << "forbiden_respond\n";
  496.             forbiden_respond();
  497.             modfd(epfd, client_fd, EPOLLOUT);
  498.             break;
  499.         }
  500.         case NOT_FOUND://404
  501.         {
  502.             cout<<"not_found_request"<< endl;
  503.             not_found_request();
  504.             modfd(epfd, client_fd, EPOLLOUT);
  505.             break;   
  506.         }
  507.         case FILE_REQUESTION://GET文件资源无问题
  508.         {
  509.             cout << "文件file request\n";
  510.             succeessful_respond();
  511.             modfd(epfd, client_fd, EPOLLOUT);
  512.             break;
  513.         }
  514.         case DYNAMIC_FILE://动态请求处理
  515.         {
  516.             cout << "动态请求处理\n";
  517.             cout << filename << " " << argv << endl;
  518.             dynamic(filename, argv);
  519.             modfd(epfd, client_fd, EPOLLOUT);
  520.             break;
  521.         }
  522.         case POST_FILE://POST 方法处理
  523.         {
  524.             cout << "post_respond\n";
  525.             post_respond();
  526.             break;
  527.         }
  528.         default:
  529.         {
  530.             close_coon();
  531.     }
  532.  
  533.     }
  534. }
  535.  
  536.  
  537.  
  538. bool http_coon::mywrite()
  539. {
  540.     if(m_flag)//如果是动态请求，返回填充体
  541.     {
  542.         int ret=send(client_fd,requst_head_buf,strlen(requst_head_buf),0);
  543.         int r = send(client_fd,body,strlen(body),0);
  544.         if(ret>0 && r>0)
  545.         {
  546.             return true;
  547.         }
  548.     }
  549.     else{
  550.             int fd = open(filename,O_RDONLY);
  551.             assert(fd != -1);
  552.             int ret;
  553.             ret = write(client_fd,requst_head_buf,strlen(requst_head_buf));
  554.             if(ret < 0)
  555.             {
  556.                 close(fd);
  557.                 return false;
  558.             }
  559.             ret = sendfile(client_fd, fd, NULL, file_size);
  560.             if(ret < 0)
  561.             {
  562.                 close(fd);
  563.                 return false;
  564.             }
  565.             close(fd);
  566.             return true;
  567.     }
  568.     return false;
  569. }
  570. #endif

其中两个附加功能加法和减法的实现（通过GET方法请求），以及POST方法请求的加法和减法的实现

  • 动态请求是什么样子(GET)

sum.html文件：

  1. <html>
  2. <head> 
  3. <meta charset="utf-8"> 
  4. <title>sum</title> 
  5. </head>
  6. <body>
  7.  
  8. <form action="add">
  9. a: <input type="text" name="a"><br>
  10. b: <input type="text" name="b"><br>
  11. <input type="submit" value="提交">
  12. </form>
  13.  
  14. <p>点击"提交"按钮，表单数据将被发送到服务器上的“add”程序上。</p>
  15.  
  16. </body>
  17. </html>

服务器收到的请求是这样的，首先是打开sum.html文件

然后在表单上提交要相加的两个数字

点击提交后，此时服务器收到的请求是这样的：

看到了/add?a=33&b=33 这就是通过方法GET提交上来的参数a和b ，此时我们在解析请求行的时候就可以通过问好来判断是否是GET的动态请求，若是那么根据sscanf()函数，分离出参数a和b，进行相加后就可以填充HTTP响应发送给浏览器了。此处我根据提交的程序名称来选择函数，在函数中相加填充返回给浏览器。当然我觉得正确的做法是重新写一个add.c然后执行生产add文件，再在fork()一个子线程通过execl( )函数去执行。

  • 那么POST请求又是什么样子呢，其实POST请求将参数放在了请求

修改后的sum.html文件

  1. <html>
  2. <head> 
  3. <meta charset="utf-8"> 
  4. <title>sum</title> 
  5. </head>
  6. <body>
  7.  
  8. <form action="add" method="post">
  9. a: <input type="text" name="a"><br>
  10. b: <input type="text" name="b"><br>
  11. <input type="submit" value="提交">
  12. </form>
  13.  
  14. <p>点击"提交"按钮，表单数据将被发送到服务器上的“add”程序上。</p>
  15.  
  16. </body>
  17. </html>

加入了属性method="post"，此时打开sum.html文件依然是GET方法，只是点击提交表单后用的是POST方法。

和GET不同的是，参数被在请求的数据部分，也就是空行之后，此时若方法是POST的话，根据read_buf_len和Content_Length就可以求出参数在read_buf中的起始位置。然后又可以通过sscanf( )分离参数了，然后fork()一个进程，利用dup2函数，将标准输出重定向到浏览器的sockfd上，再执行execl( )函数。此时我们的add执行文件的.c文件如下：

  1. #include<stdio.h>
  2. #include<string.h>
  3. int main(int argc, char *argv[])
  4. {
  5.     char re_head[1000];
  6.     char message[1000];
  7.     int ret;
  8.     int a,b,result;
  9.     ret = sscanf(argv[0],"a=%d&b=%d", &a, &b);
  10.     //printf("a=%d\t b=%d\n",a,b);
  11.     if(ret < 0 || ret != 2)
  12.     {
  13.         sprintf(message,"<html><body>\r\n");
  14.         sprintf(message,"%s<p>failure</p>\r\n",message);
  15.         sprintf(message,"%s</body></html>");
  16.  
  17.         sprintf(re_head,"HTTP/1.1 GET\r\n");
  18.         sprintf(re_head,"%scontent-length: %d\r\n",re_head,strlen(message));
  19.         sprintf(re_head,"%scontent-type: text/html\r\n",re_head);
  20.         sprintf(re_head,"%sconection: close\r\n\r\n");
  21.         /*错误提示消息*/
  22.     }
  23.     else{
  24.         result = a+b;
  25.         /*返回正确信息*/
  26.         sprintf(message,"<html><body>\r\n");
  27.         sprintf(message,"%s<p>%d + %d = %d</p><br>\r\n",message,a,b,result);
  28.         sprintf(message,"%s<p>welcome to the word of jialuhu</p><br>\r\n",message);
  29.         sprintf(message,"%s</body></html>\r\n",message);
  30.         
  31.         sprintf(re_head,"HTTP/1.1 200 ok\r\n");
  32.         sprintf(re_head,"%sContent-length: %d\r\n",re_head,(int)strlen(message));
  33.         sprintf(re_head,"%scontent-type: text/html\r\n\r\n",re_head);
  34.        // sprintf(re_head,"%sconection: close\r\n\r\n");
  35.     }
  36.     printf("%s",re_head);
  37.     printf("%s",message);
  38.     fflush(stdout);
  39.     return 0;
  40. }

当然除了加减法，还有很多功能可以去实现。此处就简单实现了这些功能。还有一些HTML文件，因为懒癌原因，所以随便写了几个。

五、总结

纵观博客其实感觉涉及的知识有点杂乱，但是很综合吧。首先满足代码上高性能的需求，利用了线城池和epoll多路复用，其中也包括同步机制的封装。其次就是HTTP这块的知识了，包括请求格式响应格式和请求方法和响应状态码，很多很多都是零零碎碎平凑一起的。而且感觉这个服务器的实现，也终于明白了浏览器和后台是怎么沟通交流的，有时候看不如动手实现下，很多东西就会突然明白了。大体模块就是epoll、线城池、同步机制、逻辑处理。代码里肯定也有很多没有测试出来的bug，但是实现大概三分之二后还是有丢丢开心的吧。

完整的代码在github上：https://github.com/jialuhu/2018/tree/master/minyweb_sever

 

 

 

 

 

posted @ 2019-07-31 17:42  xjyxp01  阅读(2007)  评论(0)  编辑  收藏  举报