devbox
Guff_9hys
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ Webserver从零开始：代码书写（十四）——http连接处理_webserver c++项目手写

作者：Guff_9hys | 2024-08-15 01:08:30

赞

踩

webserver c++项目手写

        感谢人迹22同学指出了init函数和do_request()函数的两处BUG，具体bug修正写在文末。            

                                                                                                                          2024年2月29日

前言

HTTP类是Webserver到目前为止最为庞大的类。其实最开始我是只想分析它的部分代码，但是最后我还咬咬牙将http连接处理的全代码分析写完了。因此，本文会特别的长，我相信没人可以把它一口气全部读完。不过我在本文中进行了细致的目录划分，除了头文件，我将http连接处理分为了 接收连接 处理连接 响应连接，大家如果嫌长，就一个部分一个部分看吧。手机端用户可以直接用下方的目录功能，PC端用户按住ctrl + 鼠标滚轮 把页面缩小一点，目录就出来了

概述

在上一章中，我们写好了线程池的代码，当时我们说说的是请求队列里面添加的元素的类型是http解析类型。具体什么是http解析，今天我们就来了解一下。

我就不在文章里给出http的原理了，感兴趣可以的同学可以去网上找。我们应该知道的是，在服务器项目中，http很重要。如果说先前我们写的线程，数据库池或者底层的小工具如locker锁等东西是地基，是骨架，那么http解析部分就是主体，是血肉。那么可以预见是，http解析部分的内容会相当地长，它应该是目前为止最长的一篇文章，我会尽可能地分段地来介绍每一部分地功能和代码，也会使用更多的拓扑图来梳理结构。如果阅读起来太累，我推荐你按分段一段一段地读，读完一段歇口气，然后再看后面的部分。我也非常推荐你把笔纸拿出来，解析一下各部分的代码，写一写它们的运行逻辑，我相信这对你帮助会非常大。

这是我画的简易的拓扑图，它的左边是浏览器，右边整个大框可以理解为部分服务器。可以看到右边的工作队列和工作线程在上一章也有体现，这里它们进入了一个更大的环境，成为了一个局部模块。

头文件

原谅我一次性把这个非常庞大的头文件丢了了上来，按一个模块一个模块地发头文件实在太费时了，而且每个知识点的具体实现大都体现在定义里，声明大家看看就好。头文件中比较重要的内容有这些：

  1. 主/状态机的状态枚举
  2. 报文解析的结果枚举
  3. io向量及buffer控制部分的变量
  1. #ifndef HTTP_CONN_H
  2. #define HTTP_CONN_H
  3. #include <unistd.h>
  4. #include <signal.h>
  5. #include <sys/types.h>
  6. #include <sys/epoll.h>
  7. #include <fcntl.h>
  8. #include <sys/socket.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11. #include <assert.h>
  12. #include <sys/stat.h>
  13. #include <string.h>
  14. #include <pthread.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <sys/mman.h>
  18. #include <stdarg.h>
  19. #include <errno.h>
  20. #include <sys/wait.h>
  21. #include <sys/uio.h>
  22. #include <map>
  23.  
  24. #include "../lock/locker.h"
  25. #include "../CGImysql/sql_connection_pool.h"
  26. #include "../timer/lst_timer.h"
  27. #include "../log/log.h"
  28.  
  29. class http_conn{
  30. public:
  31.     /*设置读取文件的名称m_rea_file大小*/
  32.     static const int FILENAME_LEN = 200;
  33.     /*设置读缓冲区m_read_buf大小*/
  34.     static const int READ_BUFFER_SIZE = 2048;
  35.     /*设置写缓冲区m_write_buf大小*/
  36.     static const int WRITE_BUFFER_SIZE = 1024;
  37.  
  38.     /*报文的请求方法，本项目只用到GET和Post*/
  39.     enum METHOD{GET = 0, POST, HEAD, PUT, DELETE, TRACE, OPTIONS, CONNECT, PATH};
  40.     /*主状态机的状态*/
  41.     enum CHECK_STATE{CHECK_STATE_REQUESTLINE = 0, CHECK_STATE_HEADER, CHECK_STATE_CONTENT};
  42.     /*报文解析结果*/
  43.     enum HTTP_CODE{NO_REQUEST, GET_REQUEST, BAD_REQUEST, NO_RESOURCE, FORBIDDEN_REQUEST, FILE_REQUEST, INTERNAL_ERROR, CLOSED_CONNECTIONS};
  44.     /*从状态机的状态*/
  45.     enum LINE_STATUS{LINE_OK = 0, LINE_BAD, LINE_OPEN};
  46.  
  47. public:
  48.     http_conn(){}
  49.     ~http_conn(){}
  50.  
  51. public:
  52.     /*初始化套接字地址，函数内部调用私有方法init*/
  53.     void init(int sockfd, const sockaddr_in &addr, char *, int, int, string user, string passwd, string sqlname);
  54.     /*关闭http连接*/
  55.     void close_conn(bool real_close = true);
  56.     void process();
  57.     /*读取浏览器端发来的全部数据*/
  58.     bool read_once();
  59.     /*响应报文写入函数*/
  60.     bool write();
  61.     sockaddr_in *get_address() {
  62.         return &m_address;
  63.     }
  64.     /*同步线程初始化数据库读取表*/
  65.     void initmysql_result(connection_pool *connPool);
  66.     int timer_flag;
  67.     int improv;
  68.  
  69. private:
  70.     void init();
  71.     /*从m_read_buf读取，并处理请求报文*/
  72.     HTTP_CODE process_read();
  73.     /*向m_write_buf写入响应报文*/
  74.     bool process_write(HTTP_CODE ret);
  75.     /*主状态机解析报文中的请求行数据*/
  76.     HTTP_CODE parse_request_line(char *text);
  77.     /*主状态机解析请求报文中的请求头数据*/
  78.     HTTP_CODE parse_headers(char *text);
  79.     /*主状态机解析报文中的请求内容*/
  80.     HTTP_CODE parse_content(char *text);
  81.     /*生成响应报文*/
  82.     HTTP_CODE do_request();
  83.  
  84.     /*m_start_line是已解析的字符*/
  85.     /*get_line用于将指针往后偏移，指向未处理的字符*/
  86.     char *get_line() {return m_read_buf + m_start_line;};
  87.     
  88.     /*从状态机读取一行，分析是请求报文的哪一部分*/
  89.     LINE_STATUS parse_line();
  90.  
  91.     void unmap();
  92.  
  93.     /*根据响应报文的格式，生成对应的8个部分，以下函数均由do_request调用*/
  94.     bool add_response(const char *format,...);
  95.     bool add_content(const char *content);
  96.     bool add_status_line(int status, const char *title);
  97.     bool add_headers(int content_length);
  98.     bool add_content_type();
  99.     bool add_content_length(int content_length);
  100.     bool add_linger();
  101.     bool add_blank_line();
  102.  
  103. public:
  104.     static int m_epollfd;
  105.     static int m_user_count;
  106.     MYSQL *mysql;
  107.     int m_state;//读事件0，写事件1
  108.  
  109. private:
  110.     int m_sockfd;
  111.     sockaddr_in m_address;
  112.  
  113.     /*存储读取的请求报文*/
  114.     char m_read_buf[READ_BUFFER_SIZE];
  115.     /*缓冲区中m_read_buf中数据的最后一个字节的下一个位置*/
  116.     long m_read_idx;
  117.     /*m_read_buf读取的位置m_checked_idx*/
  118.     long m_checked_idx;
  119.     /*m_read_buf中已经解析的字符个数*/
  120.     int m_start_line;
  121.  
  122.     /*存储发送的响应报文数据*/
  123.     char m_write_buf[WRITE_BUFFER_SIZE];
  124.     /*指示buffer中的长度*/
  125.     int m_write_idx;
  126.  
  127.     /*主状态机的状态*/
  128.     CHECK_STATE m_check_state;
  129.     /*请求方法*/
  130.     METHOD m_method;
  131.  
  132.     /*以下为解析请求报文中对应的6个变量*/
  133.     char m_real_file[FILENAME_LEN];
  134.     char *m_url;
  135.     char *m_version;
  136.     char *m_host;
  137.     long m_content_length;
  138.     bool m_linger;
  139.  
  140.     char *m_file_address;   //读取服务器上的文件地址
  141.     struct stat m_file_stat;
  142.     struct iovec m_iv[2];   //io向量机制iovec
  143.     int m_iv_count;
  144.     int cgi;                //是否启用的POST
  145.     char *m_string;         //存储请求头数据
  146.     int bytes_to_send;      //剩余发送的字节
  147.     int bytes_have_send;    //已发送的字节
  148.     char *doc_root;         //网站根目录
  149.  
  150.     map<string, string> m_users;
  151.     int m_TRIGMode;         //m_TRIGMode == 1时epoll为ET触发模式
  152.     int m_close_log;
  153.  
  154.     char sql_user[100];
  155.     char sql_passwd[100];
  156.     char sql_name[100];
  157. };
  158. #endif

定义文件

process()函数是http最为核心的函数，将process()函数的调用栈画成目录格式见下图，帮助各位同学理解各代码所处的位置。

接收连接

init

http类的初始化工作我们单独定义了一个init函数对私有成员初始化，而不是使用构造函数。我们定义两个init()，一个有参一个无参，有参init()初始化的内容是一些 根据连接进来的用户动态变化的变量，不同的连接这部分内容都不相同，而无参init()则负责将类的内部用于实现各模块功能的变量初始化，具体代码见下

  1. int http_conn::m_user_count = 0;
  2. int http_conn::m_epollfd = -1;
  3.  
  4. void http_conn::init(int sockfd, const sockaddr_in &addr, char *root, int TRIGMode,
  5.                     int close_log, string user, string passwd, string sqlname) {
  6.     m_sockfd = sockfd;
  7.     m_address = addr;
  8.  
  9.     m_TRIGMode = TRIGMode;
  10.     addfd(m_epollfd, sockfd, true, m_TRIGMode);
  11.     m_user_count++;
  12.  
  13.     /*当浏览器出现连接重置时，可能是网站根目录出错或http响应格式出错或者访问的文件中内容完全为空*/
  14.     doc_root = root;
  15.     m_close_log = close_log;
  16.  
  17.     strcpy(sql_user, user.c_str());
  18.     strcpy(sql_passwd, passwd.c_str());
  19.     strcpy(sql_name, sqlname.c_str());
  20.  
  21.     /*私有无参初始化*/
  22.     init();
  23. }

addfd

  1.  
  2. /*设置fd非阻塞*/
  3. int setnonblocking(int fd) {
  4.     int old_option = fcntl(fd, F_GETFL);
  5.     int new_option =old_option | O_NONBLOCK;
  6.     fcntl(fd, F_SETFL, new_option);
  7.     return old_option;
  8. }
  9.  
  10. /*将内核事件表注册读事件，ET模式,选择开启EPOLLONESHOT*/
  11. void addfd(int epollfd, int fd, bool one_shot, int TRIGMode) {
  12.     epoll_event event;
  13.     event.data.fd = fd;
  14.  
  15.     if (TRIGMode ==1) {
  16.         event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
  17.     } else {
  18.         event.events = EPOLLIN | EPOLLRDHUP;
  19.     }
  20.  
  21.     if (one_shot) {
  22.         event.events |= EPOLLONESHOT;
  23.     }
  24.     epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
  25.     setnonblocking(fd);
  26. }

无参init()

  1. /*初始化接收新的连接,check_state默认为分析请求行状态*/
  2. void http_conn::init() {
  3.     mysql = NULL;
  4.     bytes_to_send = 0;
  5.     bytes_have_send = 0;
  6.     m_check_state = CHECK_STATE_REQUESTLINE;
  7.     
  8.     m_linger = false;
  9.     m_method = GET;
  10.     m_url = 0;
  11.     m_version = 0;
  12.     m_content_length = 0;
  13.     m_host = 0;
  14.  
  15.     m_start_line = 0;
  16.     m_checked_idx = 0;
  17.     m_read_idx = 0;
  18.     m_write_idx = 0;
  19.  
  20.     cgi = 0;
  21.     m_state = 0;
  22.     timer_flag = 0;
  23.     improv = 0;
  24.  
  25.     memset(m_read_buf, '\0', READ_BUFFER_SIZE);
  26.     memset(m_write_buf, '\0', WRITE_BUFFER_SIZE);
  27.     memset(m_real_file, '\0', FILENAME_LEN);
  28. }

removefd, modfd

在init里面我们调用了addfd()，addfd函数实现的功能是将传进来的sockfd（也就是真正的客户端连接）注册在epoll内核事件表上，这里就是我们项目第一次开始涉及epoll了。在基础知识部分我们介绍了三种I/O复用方式：C++ Webserver从零开始：基础知识（四）——I/O复用-CSDN博客

既然使用了epoll_ctl，那epoll_create去哪了呢？其实我们的epoll_create调用还在最顶层使用，最顶层调用了epoll_create后将得到的epollfd作为参数传递给HTTP类里的init函数，init将其用以设置事件的属性。其实我们在lst_timer类里实现过一次addfd，但是lit_timer中并没有实现removefd,modfd，大家可以想一想这之中的原理。

  1. /*从内核事件表删除描述符*/
  2. void removefd(int epollfd, int fd) {
  3.     epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, 0);
  4.     close(fd);
  5. }
  6.  
  7. /*将事件重置为ONESHOT*/
  8. void modfd(int epollfd, int fd, int ev, int TRIGMode) {
  9.     epoll_event event;
  10.     event.data.fd = fd;
  11.  
  12.     if (TRIGMode == 1) {
  13.         event.events = ev | EPOLLIN | EPOLLET | EPOLLRDHUP;
  14.     } else {
  15.         event.events = ev | EPOLLIN | EPOLLRDHUP;
  16.     }
  17.     epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
  18. }

read_once()

初始化部分完成后，我们来看看http类流程图中做的第一个非常重要的事——将数据读到缓冲区。在这里我们定义了一块缓冲区m_read_buf专门用来存放从浏览器发送来的请求报文，并用一个指针m_read_idx记录、维护这个读缓冲区。这里就涉及到了服务器的一个重要知识点：LT模式和ET模式。

在LT模式下，epoll_wait会无数次地通知应用程序读事件的发生，直到应用程序去取。这里的应用程序是什么呢？很显然就是下面这个read_once()代码，在if ( m_TRIGMode == 0) 程序块里，应用程序用recv去将sockfd内的内容取到m_readbuf里面，如果没有取完，程序是无所谓的，它会继续往下执行，直到下一次epoll_wait再次通知，它便再进行recv操作。

而与此相对应的是另一个程序控制块，即ET模式，在ET模式下，epoll_wait只会通知应用程序一次，应用程序被要求在这一次就把sockfd中全部的数据取出，即read_once，可以看到在ET模式下，代码执行一个永不结束的循环while(true），唯有当数据全部取完（即recv返回-1并设置errno为EAGAIN或EWOULDBLOCK)时，程序才会退出，不然程序就一直循环下去。（其实当对方关闭了sock连接也会退出，但这就属于异常处理的流程，而非常规流程了）

  1. bool http_conn::read_once() {
  2.     if (m_read_idx >= READ_BUFFER_SIZE) {
  3.         return false;
  4.     }
  5.     int bytes_read = 0;
  6.  
  7.     /*LT模式*/
  8.     if (m_TRIGMode == 0) {
  9.         bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
  10.         m_read_idx += bytes_read;
  11.  
  12.         if (bytes_read <= 0) {
  13.             return false;
  14.         }
  15.         return true;
  16.     } else {
  17.         /*ET模式*/
  18.         while (true)
  19.         {
  20.             bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
  21.             if (bytes_read == -1) {
  22.                 /*当errno == EAGAIN或EWOULDBLOCK时，表示没有数据可读，需要稍后尝试*/
  23.                 if (errno == EAGAIN || errno == EWOULDBLOCK) {
  24.                     break;
  25.                 }
  26.                 return false;
  27.             }
  28.             /*对方关闭连接*/
  29.             else if (bytes_read == 0) {
  30.                 return false;
  31.             }
  32.             m_read_idx += bytes_read;
  33.         }
  34.         return true;
  35.     }
  36. }

到此为止，http类接收浏览器连接的代码就结束了，接下来介绍http处理连接部分的代码。

处理连接

在处理连接部分，我们设计了两个状态机主状态机/从状态机来进行报文解析。下图是处理连接的拓扑图：

  • 从状态机负责读取一行的数据
  • 当从状态机成功读完一行后，就将这行数据交给主状态机
  • 主状态机会根据报文格式以及自身状态对该请求行进行解析
  • 解析完后主状态机的状态改变，切换到下一个状态再等待从状态机的数据循环

如果是GET请求，则在CHECK_STATE_HEADER状态中调用do_request

如果是POST请求，则在CHECK_STATE_CONTENT状态中调用do_request

从状态机设计

在上面的read_once()函数中我们获得了一个字符数组m_read_buf，和一个指针m_read_idx。在从状态机中，我们开始读取m_read_buf至今为止保存的内容。这时我们需要创建一个新的指针m_checked_idx来记录每一行报文的结束地址。这是因为http报文是按行来分开不同的信息的，所以我们在确定m_checked_idx的结束地址时，可以根据C中的换行转义符 \r\n 来进行判断。下面是从状态机的运行逻辑：

  • 从状态机从m_read_buf中逐字节地读，判断当前字符是否为\r
    • 判断\r下一个字符是否为\n，若是，将\r\n改为\0\0，返回LINE_OK
    • 若下一个字符是m_read_idx说明未读完（LT），则返回LINE_OPEN
    • 否则，返回LINE_BAD
  • 判断当前字符是否是\n
    • 判断上一个字符是否是\r，若是，将\r\n改为\0\0，返回LINE_OK

大家可以思考一下，什么情况下当前字符会是\n，而上一个字符是\r（若有不清楚的，可以在评论区提问）

  1. /*从状态机，用于分析出一行的内容
  2.   返回值为行的读取状态，有LINE_OK,LINE_BAD,LINE_OPEN*/
  3. http_conn::LINE_STATUS http_conn::parse_line() {
  4.     char temp;
  5.     for (; m_checked_idx < m_read_idx; ++m_checked_idx) {
  6.         temp = m_read_buf[m_checked_idx];
  7.         if (temp == '\r') {
  8.             if ((m_checked_idx + 1) == m_read_idx) {
  9.                 return LINE_OPEN;
  10.             } else if (m_read_buf[m_checked_idx + 1] == '\n') {
  11.                 m_read_buf[m_checked_idx++] = '\0';
  12.                 m_read_buf[m_checked_idx++] = '\0';
  13.                 return LINE_OK;
  14.             }
  15.             return LINE_BAD;
  16.         }
  17.         else if (temp == '\n') {
  18.             if (m_checked_idx > 1 && m_read_buf[m_checked_idx - 1] == '\r') {
  19.                 m_read_buf[m_checked_idx - 1] = '\0';
  20.                 m_read_buf[m_checked_idx++] = '\0';
  21.                 return LINE_OK;
  22.             }
  23.             return LINE_BAD;
  24.         }
  25.     }
  26.     return LINE_OPEN;
  27. }

主状态机-parse_request_line函数

分析http报文格式，我们得知第一行里记录了http报文的类型，url（GET类型），版本号。我们便可以开始着手写主状态机的第一个函数了。

  1. /*解析http请求行，获得请求方法，目标url及http版本号*/
  2. http_conn::HTTP_CODE http_conn::parse_request_line(char *text) {
  3.     m_url = strpbrk(text, " \t");//将找到的第一个空格或者水平制表符返回
  4.     if (!m_url) {
  5.         return BAD_REQUEST;
  6.     }
  7.  
  8.     /*将该位置改为0，并将前面的数据取出*/
  9.     *m_url++ = '\0';
  11.     /*取出数据，通过与GET和POST比较，确定请求方式*/
  12.     char *method = text;
  13.     if (strcasecmp(method, "GET") == 0) {
  14.         m_method = GET;
  15.     } else if (strcasecmp(method, "POST") == 0) {
  16.         m_method = POST;
  17.         cgi = 1;
  18.     } else 
  19.         return BAD_REQUEST;
  20.     
  21.     /*m_url此时跳过了第一个空格或\t字符，但不知道后面是否还有
  22.       将m_url向后偏移，通过查找，继续跳过空格和\t，指向请求资源的第一个字符*/
  23.     m_url += strspn(m_url, " \t");
  24.     /*同样的方法判断HTTP版本号*/
  25.     m_version = strpbrk(m_url, " \t");
  26.     if (!m_version) {
  27.         return BAD_REQUEST;
  28.     }
  29.     *m_version++ = '\0';
  30.     m_version += strspn(m_version, " \t");
  31.     if (strcasecmp(m_version, "HTTP/1.1") != 0) {
  32.         return BAD_REQUEST;
  33.     }
  34.     if (strncasecmp(m_url, "http://", 7) == 0) {
  35.         m_url += 7;
  36.         m_url = strchr(m_url, '/');
  37.     }
  38.  
  39.     if (strncasecmp(m_url, "https://", 8) == 0) {
  40.         m_url += 8;
  41.         m_url = strchr(m_url, '/');
  42.     }
  43.  
  44.     if (!m_url || m_url[0] != '/') {
  45.         return BAD_REQUEST;
  46.     }
  47.  
  48.     if (strlen(m_url) == 1) {
  49.         strcat(m_url, "judge.html");
  50.     }
  51.     m_check_state = CHECK_STATE_HEADER;
  52.     return NO_REQUEST;
  53. }

主状态机--parse_headers函数

解析完请求行，我们再来解析请求头部，根据报文格式，以及头部字段名的种类，我们有下面的代码

  1. /*解析http请求的一个头部信息*/
  2. http_conn::HTTP_CODE http_conn::parse_headers(char *text) {
  3.     /*判断是空行还是请求头*/
  4.     if (text[0] == '\0') {
  5.         if (m_content_length != 0) {
  6.             m_check_state = CHECK_STATE_CONTENT;
  7.             return NO_REQUEST;
  8.         }
  9.         return GET_REQUEST;
  10.     }
  11.     /*解析请求头部连接字段*/
  12.     else if (strncasecmp(text, "Connection:", 11) == 0) {
  13.         text += 11;
  14.         /*跳过空格和\t字符*/
  15.         text += strspn(text, " \t");
  16.         if (strcasecmp(text, "keep-alive") == 0) {
  17.             /*如果是长连接，把m_linger设为true*/
  18.             m_linger = true;
  19.         }
  20.     }
  21.     /*解析请求头部内容长度字段*/
  22.     else if (strncasecmp(text, "Content-length:", 15) == 0) {
  23.         text += 15;
  24.         text += strspn(text, " \t");
  25.         m_content_length = atol(text);
  26.     }
  27.     /*解析请求头部HOST字段*/
  28.     else if (strncasecmp(text, "Host:", 5) == 0) {
  29.         text += 5;
  30.         text += strspn(text, " \t");
  31.         m_host = text;
  32.     }
  33.     else {
  34.         LOG_INFO("oop!unkonw header: %s", text);
  35.     }
  36.     return NO_REQUEST;
  37. }

主状态机--parse_content函数

最后解析请求数据，在我们这个项目中,POST请求发送的是用户名和密码。以此来实现注册登录功能，实际Web中parse_content的内容要多得多得多。

  1. /*判断http请求是否被完整读入*/
  2. http_conn::HTTP_CODE http_conn::parse_content(char *text) {
  3.     if (m_read_idx >= (m_content_length + m_checked_idx)) {
  4.         text[m_content_length] = '\0';
  5.         /*POST请求中最后为输入的用户名和密码*/
  6.         m_string = text;
  7.         return GET_REQUEST;
  8.     }
  9.     return NO_REQUEST;
  10. }

主状态机实现--process_read

实现了三个parse函数，我们现在来完成主状态机的设计。主状态机的设计主要是根据我们的拓扑图。

这里的while（循环）进入条件：

((line_status = parse_line()) == LINE_OK)

当从状态机为LINE_OK时，主状态机循环就可以继续

m_check_state == CHECK_STATE_CONTENT && line_status == LINE_OK

在POST请求报文中，因为消息体结尾没有 \r\n ，所以不会触发parse_line()解析，所以我们只能根据主状态机进行条件判断进入循环。但这会有个问题，等POST请求报文全部解析完后，m_check_state依然是CHECK_STATE_CONTENT,还是不会退出循环。这不是我们所希望的，所以我们让它加上 line_status == LINE_OK,这样当POST消息体全部解析完后，line_status会被赋值为LINE_OPEN,就不再进入主循环

有限状态机部分，比较简单，具体的逻辑在拓扑图中也有，就不细说了

  1. http_conn::HTTP_CODE http_conn::process_read() {
  2.     /*初始化从状态机状态，HTTP请求解析结果*/
  3.     LINE_STATUS line_status = LINE_OK;
  4.     HTTP_CODE ret = NO_REQUEST;
  5.     char* text = 0;
  6.  
  7.     /*parse_line为从状态机的具体实现*/
  8.     while( ((line_status = parse_line()) == LINE_OK) || (m_check_state == CHECK_STATE_CONTENT && line_status == LINE_OK) ) {
  9.         text = get_line();
  10.  
  11.         /*m_checked_idx是每一个数据行在m_read_buf中的起始位置*/
  12.         /*m_checked_idx表示从状态机在m_read_buf中读取的位置*/
  13.         m_start_line = m_checked_idx;
  14.  
  15.         LOG_INFO("%s", text);
  16.         /*主状态机三种状态转移逻辑转移*/
  17.         switch (m_check_state)
  18.         {
  19.             case CHECK_STATE_REQUESTLINE:
  20.             {
  21.                 /*解析请求行*/
  22.                 ret = parse_request_line(text);
  23.                 if (ret == BAD_REQUEST) {
  24.                     return BAD_REQUEST;
  25.                 }
  26.                 break;
  27.             }
  28.             case CHECK_STATE_HEADER:
  29.             {
  30.                 /*解析请求头*/
  31.                 ret = parse_headers(text);
  32.                 if (ret == BAD_REQUEST) {
  33.                     return BAD_REQUEST; 
  34.                 }
  35.                 /*完整解析GET请求后，跳转到报文响应函数*/
  36.                 else if (ret == GET_REQUEST) {
  37.                     return do_request();
  38.                 }
  39.                 break;
  40.             }
  41.             case CHECK_STATE_CONTENT:
  42.             {
  43.                 /*解析消息体*/
  44.                 ret = parse_content(text);
  45.  
  46.                 /*完整解析POST请求后，跳转到报文响应函数*/
  47.                 if (ret == GET_REQUEST) {
  48.                     return do_request();
  49.                 }
  50.  
  51.                 /*解析完消息体即完成了报文解析，为了避免再次进入循环，更新line_status*/
  52.                 line_status = LINE_OPEN;
  53.                 break;
  54.             }
  55.         
  56.         default:
  57.             return INTERNAL_ERROR;
  58.         }
  59.     }
  60.     return NO_REQUEST;
  61. }

响应连接

OK，我们的http解析流程进入最后一步，响应连接。

do_request

在do_request部分，我们实现对POST请求的响应连接。同时我们在这里实现一个简易的注册登录功能。

我们要实现注册功能，就需要使用数据库，根据POST消息体中的写好的账户和密码，我们将其保存在数据库中（保存前先验证是否重复）。然后在GET请求中，我们再看数据库中的账户和密码与用户登录用的账户密码是否匹配（真正的登录注册功能实现比这要复杂），如果匹配，才返回用户请求的资源。

除此之外，我们根据m_url中最后一个‘/’的后一位的字符来判断返回给用户什么资源

  1. http_conn::HTTP_CODE http_conn::do_request() {
  2.     strcpy(m_real_file, doc_root);
  3.     int len = strlen(doc_root);
  4.     /*找到m_url中/的位置*/
  5.     const char *p = strrchr(m_url, '/');
  6.  
  7.     /*处理CGI*/
  8.     if (cgi == 1 && (*(p + 1) == '2' || *(p + 1) =='3')) {
  9.         /*根据标志判断是登录检测还是注册检测*/
  10.         char flag = m_url[1];
  11.  
  12.         char *m_url_real = (char *)malloc(sizeof(char)* 200);
  13.         strcpy(m_url_real, "/");
  14.         strcat(m_url_real, m_url + 2);
  15.         strncpy(m_real_file + len, m_url_real, FILENAME_LEN - len - 1);
  16.         free(m_url_real);
  17.  
  18.         /*提取用户名和密码*/
  19.         char name[100], password[100];
  20.         int i;
  21.         for (i = 5; m_string[i] != '&'; ++i)
  22.             name[i - 5] = m_string[i];
  23.         name[i - 5] = '\0';
  24.  
  25.         int j = 0;
  26.         for (i = i + 10; m_string[i] != '\0'; ++i, ++j)
  27.             password[j] = m_string[i];
  28.         password[j] = '\0';
  29.  
  30.         if (*(p + 1) == '3') {
  31.             /*如果是注册，先检测数据库中是非有重名的
  32.               没有重名，增加数据*/
  33.             char *sql_insert = (char *)malloc(sizeof(char) * 200);
  34.             strcpy(sql_insert, "INSERT INTO user(username, passwd) VALUES(");
  35.             strcat(sql_insert, "'");
  36.             strcat(sql_insert, name);
  37.             strcat(sql_insert, "', '");
  38.             strcat(sql_insert, password);
  39.             strcat(sql_insert, "')");
  40.  
  41.             if (users.find(name) == users.end()) {
  42.                 m_lock.lock();
  43.                 /*SQL查询*/
  44.                 int res = mysql_query(mysql,sql_insert);
  45.                 users.insert(pair<string, string>(name, password));
  46.                 m_lock.unlock();
  47.  
  48.                 if (!res) {
  49.                     strcpy(m_url, "/log.html");
  50.                 } else {
  51.                     strcpy(m_url, "/registerError.html");
  52.                 }
  53.             } else {
  54.                 strcpy(m_url, "/registerError.html");
  55.             }
  56.         }
  57.         /*如果是登录，直接判断
  58.         若浏览器端输入的用户名和密码在表中可以查找到，返回1，否则返回0*/
  59.         else if (*(p + 1) == '2') {
  60.             if (users.find(name) != users.end() && users[name] == password) {
  61.                 strcpy(m_url, "/welcome.html");
  62.             } else {
  63.                 strcpy(m_url, "/logError.html");
  64.             }
  65.         }
  66.     }
  67.  
  68.     /*如果请求资源为/0，表示跳转注册界面*/
  69.     if (*(p + 1) == '0') {
  70.         char *m_url_real = (char *)malloc(sizeof(char) * 200);
  71.         strcpy(m_url_real, "/register.html");
  72.  
  73.         /*将网站目录和/register.html进行拼接，更新到m_real_file中*/
  74.         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
  75.         free(m_url_real);
  76.     }
  77.     /*请求资源为/1，表示跳转登录界面*/
  78.     else if (*(p + 1) == '1') {
  79.         char *m_url_real = (char *)malloc(sizeof(char) * 200);
  80.         strcpy(m_url_real, "/log.html");
  81.  
  82.         strncpy(m_real_file + len, m_url_real, sizeof(m_url_real));
  83.         free(m_url_real);
  84.     }
  85.     else if (*(p + 1) == '5')
  86.     {
  87.         char *m_url_real = (char *)malloc(sizeof(char) * 200);
  88.         strcpy(m_url_real, "/picture.html");
  89.         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
  90.  
  91.         free(m_url_real);
  92.     }
  93.     else if (*(p + 1) == '6')
  94.     {
  95.         char *m_url_real = (char *)malloc(sizeof(char) * 200);
  96.         strcpy(m_url_real, "/video.html");
  97.         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
  98.  
  99.         free(m_url_real);
  100.     }
  101.     else if (*(p + 1) == '7')
  102.     {
  103.         char *m_url_real = (char *)malloc(sizeof(char) * 200);
  104.         strcpy(m_url_real, "/fans.html");
  105.         strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
  106.  
  107.         free(m_url_real);
  108.     }
  109.     else {
  110.         strncpy(m_real_file + len, m_url, FILENAME_LEN - len - 1);
  111.     }
  112.  
  113.     if (stat(m_real_file, &m_file_stat) < 0) {
  114.         return NO_RESOURCE;
  115.     }
  116.     /*如果文件不可读，返回FORBIDDEN_REQUEST*/
  117.     if (!(m_file_stat.st_mode & S_IROTH)) {
  118.         return FORBIDDEN_REQUEST;
  119.     }
  120.     /*如果是目录，返回BAD_REQUEST*/
  121.     if (S_ISDIR(m_file_stat.st_mode)) {
  122.         return BAD_REQUEST;
  123.     }
  124.     /*以只读方式获取文件描述符，通过mmap将该文件描述符映射到内存*/
  125.     int fd = open(m_real_file, O_RDONLY);
  126.     m_file_address = (char *)mmap(0, m_file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
  127.  
  128.     close(fd);
  129.     /*请求文件存在，可以访问*/
  130.     return FILE_REQUEST;
  131.  
  132. }

add_response

我们定义一个基础的往HTTP响应的缓冲区添加格式化的数据的函数，并且使用可变参数va_list增加它的可复用性。这样我们后面的各种写数据就可以直接调用add_response了。

  1. bool http_conn::add_response(const char *format, ...) {
  2.     /*若写入内容超出m_write_buf大小则报错*/
  3.     if (m_write_idx >= WRITE_BUFFER_SIZE) {
  4.         return false;
  5.     }
  6.     /*定义可变参数列表*/
  7.     va_list arg_list;
  8.     va_start(arg_list, format);
  9.  
  10.     /*将数据format从可变参数列表写入缓冲区，返回写入数据长度*/
  11.     int len = vsnprintf(m_write_buf + m_write_idx, WRITE_BUFFER_SIZE - 1 - m_write_idx, format, arg_list);
  12.     /*若写入的数据长度比缓冲区剩下的空间大，则报错*/
  13.     if (len >= (WRITE_BUFFER_SIZE - 1 - m_write_idx)) {
  14.         va_end(arg_list);
  15.         return false;
  16.     }
  17.     /*更新m_write_idx位置*/
  18.     m_write_idx += len;
  19.     va_end(arg_list);
  20.     LOG_INFO("request:%s", m_write_buf);
  21.     return true;
  22. }

调用add_response的函数系列

  1. /*添加状态行*/
  2. bool http_conn::add_status_line(int status, const char *title) {
  3.     return add_response("%s %d %s\r\n", "HTTP/1.1", status, title);
  4. }
  5.  
  6. /*添加消息报头，具体的添加长度文本 连接状态 和空行*/
  7. bool http_conn::add_headers(int content_len) {
  8.     return add_content_length(content_len) && add_linger() && add_blank_line();
  9. }
  10. bool http_conn::add_content_length(int content_len) {
  11.     return add_response("Content-Length:%d\r\n", content_len);
  12. }
  13. bool http_conn::add_content_type() {
  14.     return add_response("Content-Type:%s\r\n", "text/html");
  15. }
  16. bool http_conn::add_linger() {
  17.     return add_response("Connection:%s\r\n",(m_linger == true) ? "keep-alive" : "close");
  18. }
  19. bool http_conn::add_blank_line() {
  20.     return add_response("%s", "\r\n");
  21. }
  22. bool http_conn::add_content(const char *content) {
  23.     return add_response("%s", content);
  24. }

process_write

我们在决定好要给浏览器返回什么数据前，还需要根据服务器状态的不同，将不同的数据填入写缓冲区。这与接受连接时，服务器将数据从读缓冲区读出解析相对应。在http协议中定义有状态码，这些状态码给浏览器一些信息以表示服务器资源不同的状态。其中，正常访问的状态以200开头，则在下面的代码中，唯有当HTTP_CODE状态码为FILE_REQUEST(对应200状态码）时，应用程序才正常地往缓冲区写浏览器请求的数据。

  1. const char *ok_200_title = "OK";
  2. const char *error_400_title = "Bad Request";
  3. const char *error_400_form = "Your request has bad syntax or is inherently impossible to staisfy.\n";
  4. const char *error_403_title = "Forbidden";
  5. const char *error_403_form = "You do not have permission to get file form this server.\n";
  6. const char *error_404_title = "Not Found";
  7. const char *error_404_form = "The requested file was not found on this server.\n";
  8. const char *error_500_title = "Internal Error";
  9. const char *error_500_form = "There was an unusual problem serving the request file.\n";
  1. bool http_conn::process_write(HTTP_CODE ret) {
  2.     switch (ret)
  3.     {
  4.     case INTERNAL_ERROR:
  5.     {
  6.         add_status_line(500, error_500_title);
  7.         add_headers(strlen(error_500_form));
  8.         if (!add_content(error_500_form)) {
  9.             return false;
  10.         }
  11.         break;
  12.     }
  13.     case BAD_REQUEST:
  14.     {
  15.         add_status_line(404, error_404_title);
  16.         add_headers(strlen(error_404_form));
  17.         if (!add_content(error_404_form)) {
  18.             return false;
  19.         }
  20.         break;
  21.     }
  22.     case FORBIDDEN_REQUEST:
  23.     {
  24.         add_status_line(403, error_403_title);
  25.         add_headers(strlen(error_403_form));
  26.         if (!add_content(error_403_form))
  27.             return false;
  28.         break;
  29.     }
  30.     case FILE_REQUEST:
  31.     {
  32.         add_status_line(200, ok_200_title);
  33.         if (m_file_stat.st_size != 0) {
  34.             add_headers(m_file_stat.st_size);
  35.             m_iv[0].iov_base = m_write_buf;
  36.             m_iv[0].iov_len = m_write_idx;
  37.             m_iv[1].iov_base = m_file_address;
  38.             m_iv[1].iov_len = m_file_stat.st_size;
  39.             m_iv_count = 2;
  40.             bytes_to_send = m_write_idx + m_file_stat.st_size;
  41.             return true;
  42.         } else {
  43.             const char *ok_string = "<html><body></body></html>";
  44.             add_headers(strlen(ok_string));
  45.             if (!add_content(ok_string)) {
  46.                 return false;
  47.             }
  48.         }
  49.     }
  50.     default:
  51.         return false;
  52.     }
  53.  
  54.     m_iv[0].iov_base = m_write_buf;
  55.     m_iv[0].iov_len = m_write_idx;
  56.     m_iv_count = 1;
  57.     bytes_to_send = m_write_idx;
  58.     return true;
  59. }

write

在写缓冲区写满要发送的数据后，我们最后调用write将其发送给浏览器。这里要注意的API是writev,writev用于一次函数调用写多个非连续缓冲区。在循环里面调用writev时，需要重新处理iovec向量中的指针和长度，writev不会对它们作任何处理。

在write函数中，服务器的子线程注册epollout事件，将缓冲区中的数据存入sock文件描述符，发给浏览器，浏览器进行解析，然后把画面渲染出来，一个网络地址访问的一生就结束了。

  1. bool http_conn::write() {
  2.     int temp = 0;
  3.     
  4.     /*响应报文为空*/
  5.     if (bytes_to_send == 0) {
  6.         modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
  7.         init();
  8.         return true;
  9.     }
  10.  
  11.     while (1) {
  12.         /*将响应报文状态行，消息头，空行和响应正文发给浏览器端*/
  13.         temp = writev(m_sockfd, m_iv, m_iv_count);
  14.  
  15.         /*未发送*/
  16.         if (temp < 0) {
  17.             /*判断缓冲区是否满了*/
  18.             if (errno == EAGAIN) {
  19.                 modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
  20.                 return true;
  21.             }
  22.             unmap();
  23.             return false;
  24.         }
  25.  
  26.         bytes_have_send += temp;
  27.         bytes_to_send -= temp;
  28.         /*第一个iovec头部信息已发完，发第二个*/
  29.         if (bytes_have_send >= m_iv[0].iov_len) {
  30.             m_iv[0].iov_len = 0;
  31.             m_iv[1].iov_base = m_file_address + (bytes_have_send - m_write_idx);
  32.             m_iv[1].iov_len = bytes_to_send;
  33.         } else {
  34.             /*继续发第一个*/
  35.             m_iv[0].iov_base = m_write_buf + bytes_have_send;
  36.             m_iv[0].iov_len = m_iv[0].iov_len - bytes_have_send;
  37.         }
  38.         /*数据已全部发完*/
  39.         if (bytes_to_send <= 0) {
  40.             unmap();
  41.             /*epoll上重置EPOLLONESHOT事件*/
  42.             modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
  43.             /*请求为长连接*/
  44.             if (m_linger) {
  45.                 /*重新初始化HTTP对象*/
  46.                 init();
  47.                 return true;
  48.             } else {
  49.                 return false;
  50.             }
  51.         }
  52.     }
  53. }

封装运行函数--process

最后，我们将http内部的代码封装成一个简单的process函数，将我们所有的设计，细节，心血藏于这短短11行普普通通的代码，这也许就是封装的魅力吧。

  1. void http_conn::process() {
  2.     HTTP_CODE read_ret = process_read();
  3.     if (read_ret == NO_REQUEST) {
  4.         modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
  5.         return;
  6.     }
  7.     bool write_ret = process_write(read_ret);
  8.     if (!write_ret) {
  9.         close_conn();
  10.     }
  11.     modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
  12. }

结束语

HTTP类我们就完成了，下一章我们开始写最顶层的一个server封装类。将我们至今为止写的所有代码，封装到一个类里，去实现它们的使命。

bug修正：

        见下图，do_request()函数中lock()加在if条件判断里面可能导致两个账户同时创建一个users.name的情况。需要将m_lock.unlock()移到if外，并在else里面添加解锁。

        这种错误在MySQL的并发中有个专有名词：幻读。幻读只有在Serializable隔离级别中才可以被避免，而MySQL的默认级别刚好是REPEATABLE-RAED，刚好无法解决幻读问题，所以这个BUG可能会导致MySQL报错。

                                                                                                                      此图来源：人迹22同学

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Guff_9hys/article/detail/981441
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号