WebServer 之 http连接处理（上）

目录

🌼基础知识

epoll

[HTTP 报文格式](#HTTP 报文格式)

[HTTP 状态码](#HTTP 状态码)

有限状态机

[🌙http 处理流程](#🌙http 处理流程)

[🐎http 报文处理](#🐎http 报文处理)

🎂http类

🎂请求报文--接收

[🐎epoll 相关代码](#🐎epoll 相关代码)

[🧜‍服务器接收 http 请求](#🧜‍服务器接收 http 请求)

---

🌼基础知识

epoll

此处仅对 API 和 基础知识 作介绍

epoll_create()

#include <sys/epoll.h>
int epoll_create(int size)

创建一个指示 epoll 内核事件表的文件描述符

该描述符将用作其他 epoll 系统调用的一个参数，size 不起作用

epoll_ctl()

#include<sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

该函数用于操作 内核事件表 监控的文件描述符上的时间：

注册，修改，删除

• epfd：epoll_create() 的句柄
• fd：文件描述符的缩写，代表文件或者 socket 的引用

句柄：获取另一个对象的方法------一个广义的指针

• op：表示动作，用 3 个宏表示：
  • EPOLL_CTL_ADD（注册新的 fd 到 epfd）
  • EPOLL_CTL_MOD（修改已注册 fd 的监听事件）
  • EPOLL_CTL_DEL（从 epfd 删除一个 fd）
• event：告诉内核需要监听的事件

event 是 ++epoll_event 结构体指针++类型，表示内核所监听的事件，定义如下👇

struct epoll_event {
    __unit32_t events; // Epoll events
    epoll_data_t data; // User data variable
};

events 描述事件类型，其中 epoll 事件类型如下👇

• EPOLLIN： 对应的文件描述符可读
• EPOLLOUT：可写
• EPOLLPRI：对应的文件描述符有 紧急数据 可读（带外数据）
• EPOLLERR：发生错误
• EPOLLHUP：被挂断
• EPOLLET：将 EPOLL 设置为边缘触发(Edge Triggered)模式，相对水平触发(Level Triggered)而言
• EPOLLONESHOT：只监听一次事件，监听完该次后，还需要监听这个 socket 的话，需要再次将这个 socket 加入到 EPOLL 队列

epoll_wait()

#include<sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *events, int maxevents,
               int timeout)

该函数用于等待所监控文件描述符上事件的产生，返回就绪的文件描述符个数

• events -- 存储内核得到事件的集合
• maxevents -- 告知内核这个 events 多大，maxevents 要 <= 创建 epoll_create() 时的size
• timeout -- 超时时间
  • -1：阻塞
  • 0：立即返回，非阻塞
  • >0：指定毫秒
• 返回值：就绪的文件描述符个数，时间结束返回 0，出错返回 -1

select / poll / epoll

1. 调用函数
   1. select 和 poll 都是一个函数，epoll 是一组函数
2. 文件描述符数量
   1. select 通过 线性表 描述文件描述符集合，数量上限 1024
   2. poll 通过 链表 描述，突破文件描述符上限，最大可以打开文件的数目
   3. epoll 通过 红黑树 描述，最大可以打开的文件数目，通过命令
      ulimit -n number 修改，仅对当前终端有效
3. 文件描述符 从用户传向内核
   1. select / poll 将所有文件描述符 拷贝 到 内核态，每次调用都需要拷贝
   2. epoll 通过 epoll_create() 建立一颗红黑树，通过 epoll_ctl 把要监听的文件描述符注册到红黑树
4. 内核判断就绪的文件描述符
   1. select / poll 遍历文件描述符集合，判断哪个文件描述符上有时间发生
   2. epoll_create() 时，内核先在 epoll 文件系统里，建立一个红黑树，用于存储以后 epoll_ctl 传来的 fd；再建立一个 list 链表，用于存储准备就绪的事件；当 epoll_wait 调用时，仅仅观察这个 list 链表有无数据即可
   3. epoll 根据每个 fd 上面的回调函数(中断函数)判断，只有发生了事件的 socket 才会主动去调用 callback() 函数，其他空闲状态的 socket 则不会 -- 若是就绪事件，插入 list
5. 应用程序索引 就绪文件描述符
   1. select /poll 只返回发生了事件的文件描述符个数，即使知道哪个发生了事件，还是需要遍历
   2. epoll 返回发生了事件的 个数 和 结构体数组，结构体包含 socket 信息，因此直接处理返回的数组即可
6. 工作模式
   1. select / poll 只能工作在相对低效的 LT 模式下
   2. epoll 可以工作在 ET 高效模式下，还支持 EPOLLONESHOT 事件，该事件能进一步减少可读，可写和异常事件被触发的次数
7. 应用场景
   1. 当所有 fd 都是活跃连接，使用 epoll，需要建立文件系统
      此时 红黑树 和 链表，效率反而不高，不如 select 和 poll
   2. 当监测的 fd 数目较小，且各个 fd 都比较活跃时，用 select 或 poll
   3. 当监测的 fd 数目非常大，成千上万，且单位时间只有一部分 fd 处于就绪状态，用 epoll 能明显提升性能

ET，LT，EPOLLONESHOT

• LT水平触发模式
  • epoll_wait 检测到文件描述符有事件发生，就将其通知到应用程序，应用程序可以不立即处理该事件
  • 当下一次调用 epoll_wait 时，epoll_wait 还会再次向应用程序报告，直到被处理
• ET边缘出发模式
  • epoll_wait 检测到文件描述符...通知到应用程序，应用程序立即处理
• EPOLLONESHOT
  • 一个线程读取某个 socket 上的数据后开始处理，处理过程中，该 socket 又有新数据可读，此时另一个线程被唤醒读取，则同时出现 2 个线程处理同一个 socket
  • 我们希望的是，一个 socket 连接，在任一时刻，只被一个线程处理，通过 epoll_ctl 对该文件描述符注册 epolloneshot 事件，一个线程处理 socket 时，其他线程无法处理
    当该线程处理完后，需要通过 epoll_ctl 重置 epolloneshot 事件

HTTP 报文格式

HTTP报文，分为请求报文和响应报文，每种报文必须按照特有格式生成，才能被浏览器识别

浏览器向服务器发送的 -- 请求报文

服务器返回给浏览器的 -- 响应报文

请求报文

HTTP请求报文由，请求行(request line)，请求头部(header)，空行，请求数据

四部分组成

其中，请求氛围 GET 和 POST

• GET

GET /562f25980001b1b106000338.jpg HTTP/1.1
Host:img.mukewang.com
User-Agent:Mozilla/5.0 (Windows NT 10.0; WOW64)
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.106 Safari/537.36
Accept:image/webp,image/*,*/*;q=0.8
Referer:http://www.imooc.com/
Accept-Encoding:gzip, deflate, sdch
Accept-Language:zh-CN,zh;q=0.8
空行
请求数据为空

• ++请求行++：请求类型 要访问的资源 HTTP版本
• ++请求头部++ ：服务器要使用的附加信息
  • HOST -- 服务器域名
  • User-Agent -- HTTP客户端程序的信息
  • Accept -- 用户代理，可处理的媒体类型
  • Accept-Encoding -- 用户代理，支持的内容编码
  • Accept-Language -- 自然语言集
  • Content -Type -- 实现主体的媒体类型
  • Content-Length -- 实现主体的大小
  • Connection -- 连接管理（Keep-Alive 或 close）
• ++空行++：必须的
• ++请求数据++：也叫主体，可以添加任意的其他数据

• POST

POST / HTTP1.1
Host:www.wrox.com
User-Agent:Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)
Content-Type:application/x-www-form-urlencoded
Content-Length:40
Connection: Keep-Alive
空行
name=Professional%20Ajax&publisher=Wiley

响应报文

HTTP响应，也由 4 部分组成：状态行，消息报头，空行，响应正文

HTTP/1.1 200 OK
Date: Fri, 22 May 2009 06:07:21 GMT
Content-Type: text/html; charset=UTF-8
空行
<html>
      <head></head>
      <body>
            <!--body goes here-->
      </body>
</html>

• 状态行：HTTP版本号 状态码 状态消息
• 消息报头：客户端要使用的附加信息

Date -- 生成响应的日期和时间

Content-Type -- 指定MIME类型的HTML，编码类型UTF-8

• 空行：必须
• 响应正文：服务器返回给客户端的 文本信息（空行后的html为响应正文）

HTTP 状态码

• 1xx：请求已接受，继续处理
• 2xx：成功（请求正常处理完毕）
  • 200 OK -- 客户端请求被正常处理
  • 206 Partial content -- 客户端进行了范围请求
• 3xx：重定向 -- 需要更进一步的操作
  • 301 Moved Permanently：永久重定向，该资源已被永久移动到新位置，将来任何对该资源的访问，都要使用本响应返回的几个 URI 之一
  • 302 Found：临时重定向，请求的资源，临时从不通过的 URI 获得
• 4xx：客户端错误 -- 语法错误，服务器无法处理
  • 400 Bad Request：语法错误
  • 403 Forbidden：请求被服务器拒绝
• 5xx：服务器错误
  • 500 Internal Server Error：服务器，执行请求时，出现错误

有限状态机

抽象的理论模型，把有限个变量的状态变化过程，以可构造可验证的方式，呈现出来

eg：封闭的有向图
通过 if-else, switch-case 和 函数指针 实现（目的：封装逻辑）

含有状态转移的有限状态机👇

STATE_MACHINE() {
    State cur_State = type_A; // 当前状态初始化 type_A
    while (cur_State != type_C) {
        Package _pack = getNewPackage(); // 获取新数据包
        switch(cur_State) { // 根据当前状态处理
            case type_A:
                process_pkg_state_A(_pack); // 处理 type_A 数据包
                cur_State = type_B; // 切换状态
                break;
            case type_B:
                process_pkg_state_B(_pack); // 处理 type_B 数据包
                cur_State = type_C; // 切换到结束状态
                break;
        }
    }
}

该状态机包含三种状态：type_A，type_B和type_C。其中，type_A是初始状态，type_C是结束状态

状态机的当前状态记录在cur_State变量中，逻辑处理时，状态机先通过getNewPackage获取数据包，然后根据当前状态对数据进行处理，处理完后，状态机通过改变cur_State完成状态转移

有限状态机一种 ++逻辑单元内部++的一种高效编程方法，在服务器编程中，服务器可以根据不同状态或者消息类型进行相应的处理逻辑，使得程序逻辑清晰易懂

🌙http 处理流程

🐎http 报文处理

• 浏览器发出 http 连接请求，主线程创建 http 对象接收请求；并将所有数据读入对应 buffer；将该对象插入任务队列；工作线程从任务队列取出一个任务进行处理
• 工作线程取出任务后，调用 process_read() 函数，通过主从状态机对请求报文解析
• 解析完，跳转 do_request() 函数 生成响应报文，通过 process_write 写入 buffer，返回给浏览器端

🎂http类

关于 enum 枚举类型👇

列举出一组枚举值，每个枚举值都有一个与之关联的整数值，默认情况下第一个枚举值的整数值为0，后续枚举值的整数值依次递增

#include <iostream>

enum Color {
    RED, // 整数值默认为0
    GREEN, // 整数值默认为1
    BLUE // 整数值默认为2
};

int main() {
    Color selectedColor = GREEN;
    
    if (selectedColor == RED) {
        std::cout << "Selected color is red." << std::endl;
    } else if (selectedColor == GREEN) {
        std::cout << "Selected color is green." << std::endl;
    } else if (selectedColor == BLUE) {
        std::cout << "Selected color is blue." << std::endl;
    }
    
    return 0;
}

Selected color is green.

++本部分代码👇++ ，位于 TinyWebServer/http/http_conn.h，主要是 http 类的定义

class http_conn {
    public:
        // 文件名称 m_real_file 大小
        static const int FILENAME_LEN = 200;
        // 读缓冲区 m_read_buf 大小
        static const int READ_BUFFER_SIZE = 2048;
        // 写缓冲区 m_write_buf 大小
        static const int WRITE_BUFFER_SIZE = 1024;
        // 报文请求方法，GET / POST
        enum METHOD { // 定义枚举类型
            GET=0,POST,HEAD,PUT,DELETE,TRACE,
            OPTIONS,CONNECT,PATH
        };
        // 主状态机状态
        enum CHECK_STATE {
            CHECK_STATE_REQUESTLINE=0,CHECK_STATE_HEADER,
            CHECK_STATE_CONTENT
        };
        // 报文解析结果
        enum HTTP_CODE {
            NO_REQUEST,GET_REQUEST,BAD_REQUEST,NO_RESOURCE,
            FORBIDDEN_REQUEST,FILE_REQUEST,INTERNAL_ERROR,
            CLOSED_CONNECTION
        };
        // 从状态机状态
        enum LINE_STATUS {
            LINE_OK=0,LINE_BAD,LINE_OPEN
        };
    
    public:
        http_conn(){}; // 构造
        ~http_conn(){}; // 析构

    public:
        // 初始化套接字地址，函数内部调用私有方法 init
        void init(int sockfd, const sockaddr_in &addr);
        // 关闭 http 连接
        void close_conn(bool real_close=true);
        void process();
        // 读取浏览器发来的全部数据
        bool read_once();
        // 响应报文写入函数
        bool write();
        sockaddr_in *get_address() {
            return &m_address;
        }
        // 同步线程初始化数据库读取表
        void initmysql_result();
        // CGI使用线程池初始化数据库表
        void initresultFile(connection_pool *connPool);

    private:
        void init();
        // 从 m_read_buf 读取，并处理请求报文
        HTTP_CODE process_read();
        // 向 m_write_buf 写入响应报文数据
        bool process_write(HTTP_CODE ret);
        // 主状态机解析报文中的请求 行数据
        HTTP_CODE parse_request_line(char *text);
        // 主状态机解析报文中的请求 头数据
        HTTP_CODE parse_headers(char *text);
        // 主状态机解析报文中的 请求内容
        HTTP_CODE parse_content(char *text);
        // 生成响应报文
        HTTP_CODE do_request();

        // m_start_line 已经解析的字符
        // get_line 将指针向后偏移，指向未处理的字符
        char* getline() {
            return m_read_buf + m_start_line;
        }

        // 从状态机读取一行，分析是 请求报文 哪部分
        LINE_STATUS parse_line();

        void unmap();

        // 根据响应报文格式，生成对应 8 部分
        // 以下函数均有 do_request 调用
        bool add_response(const char* format, ...);
        bool add_content(const char* content);
        bool add_status_line(int status, const char* title);
        bool add_headers(int content_length);
        bool add_content_type();
        bool add_content_length(int content_length);
        bool add_linger();
        bool add_blank_line();

    public:
        static int m_epollfd;
        static int m_user_count;
        MYSQL *mysql;

    private:
        int m_sockfd;
        sockaddr_in m_address;

        // 存储读取的请求报文数据
        char m_read_buf[READ_BUFFER_SIZE];
        // 缓冲区 m_read_buf 数据最后一个字节下一位置
        int m_read_idx;
        // m_read_buf 读取的位置
        int m_checked_idx;
        // m_read_buf 已经解析的字符个数
        int m_start_line;

        // 存储发出的响应报文数据
        char m_write_buf[WRITE_BUFFER_SIZE];
        // 指示buffer中的长度
        int m_write_idx;

        // 主状态机的状态
        CHECK_STATE m_check_state;
        // 请求方法
        METHOD m_method;


        // 解析请求报文中的 6 个变量

        // 存储读取文件的名称
        char m_real_file[FILENAME_LEN];
        char *m_url;
        char *m_version;
        char *m_host;
        int m_content_length;
        bool m_linger;

        char *m_file_address; // 读取服务器上的文件地址
        struct stat m_file_stat;
        struct iovec m_iv[2]; // io 向量机制 iovec
        int m_iv_count;
        int cgi; // 是否启用的 POST
        char *m_string; // 存储 请求头数据
        int bytes_to_send; // 剩余发送字节数
        int bytes_have_send; // 已发送字节数
};

🎂请求报文--接收

在 http 请求接收部分，会涉及到 init() 和 read_once() 函数，但 init() 仅对私有成员变量初始化，不过多讲解
read_once() 读取浏览器发来的 请求报文，直到无数据可读 或 对方关闭连接

读取到 m_read_buffer，并更新 m_read_idx

// 循环读取客户数据，直到无数据可读 或 对方关闭连接
bool http_conn::read_once()
{
    if (m_read_idx >= READ_BUFFER_SIZE) {
        return false;
    }
    int bytes_read = 0;
    while (true) {
        // 从套接字接收数据，存储在 m_read_buf 缓冲区
        bytes_read = recv(m_sockfd, m_read_buf + m_read_idx,
                          READ_BUFFER_SIZE - m_read_idx, 0);
        if (bytes_read == -1) {
            // 非阻塞ET模式下，需要一次性将数据读完
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                break;
            return false;
        }
        else if (bytes_read == 0)
            return false;
        // 修改 m_read_idx 的读取字节数
        m_read_idx += bytes_read;
    }
    return true;
}

🐎epoll 相关代码

项目中 epoll 相关代码，包括 4 部分：

++非阻塞模式，内核事件表注册事件，删除事件，重置EPOLLONESHOT事件++

• 非阻塞模式

// 对文件描述符设置非阻塞
int setnonblocking(int fd)
{
    // 获取文件描述符的旧选项
    int old_option = fcntl(fd, F_GETFL); 
    // 将非阻塞选项与旧选项进行按位或运算
    int new_option = old_option | P_NONBLOCK; 
    // 将新选项设置为文件描述符的选项
    fcntl(fd, F_SETFL, new_option);
    return old_option; // 返回旧选项
}

• 内核事件表注册新事件，开启EPOLLONESHOT，针对客户端连接的描述符，listenfd不开启

// 内核事件表注册新事件，开启EPOLLONESHOT，针对客户端连接的描述符，listenfd不用开启
void addfd(int epollfd, int fd, bool one_shot)
{
    epoll_event event; // 定义事件结构体
    event.data.fd = fd; // 设置事件结构体的文件描述符

#ifdef ET
    event.events = EPOLLIN | EPOLLET | EPOLLRDHUP; // 使用边缘触发模式，设置事件类型
#endif

#ifdef LT
    event.events = EPOLLIN | EPOLLRDHUP; // 使用水平触发模式，设置事件类型
#endif

    if (one_shot)
        event.events |= EPOLLONESHOT; // 开启 EPOLLONESHOT 选项

    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event); // 将事件注册到内核事件表中
    setnonblocking(fd); // 设置文件描述符为非阻塞模式
}

• 内核事件表删除事件

void removefd(int epollfd, int fd)
{
    epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, 0);
    close(fd);
}

• 重置 EPOLLONESHOT 事件

void modfd(int epollfd, int fd, int ev)
{
    epoll_event event; // 定义事件结构体变量

    event.data.fd = fd; // 设置事件结构体文件描述符传入的 fd

#ifdef ET
    // 边缘触发模式，设置事件类型 -- 按位或结果
    // ev参数   EPOLLET边缘触发    EPOLLONESHOT一次性出发
    // EPOLLRDHUP对端关闭连接
    event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLRDHUP;
#endif

#ifdef LT
    // 水平触发模式，设置事件类型
    event.events = ev | EPOLLONESHOT | EPOLLRDHUP;
#endif

    // 修改已注册事件属性
    epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
    // &event 待修改的事件结构体
}

🧜‍服务器接收 http 请求

浏览器发出的 连接请求，主线程创建 http 对象接收请求，并将所有数据读入对应的 buffer

将该对象插入任务队列

工作线程从任务队列取出一个任务进行处理

// 创建 MAX_FD 个http类对象
http_conn* users = new http_conn[MAX_FD];

// 创建内核事件表
epoll_event events[MAX_EVENT_NUMBER];
epollfd = epoll_create(5);
assert(epollfd != -1);

// 将 listenfd 放在 epoll 树上
addfd(epollfd, listenfd, false);

// 将上述 epollfd 赋值给 http类对象的 m_epollfd 属性
http_conn::m_epollfd = epollfd;

while (!stop_server) {
    // 等待被监控的文件描述符上有事件产生
    int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
    if (number < 0 && errno != EINTR) 
        break;
    // 处理所有就绪事件
    for (int i = 0; i < number; ++i) {
        int sockfd = events[i].data.fd;

        // 处理新到的客户连接
        if (sockfd == listenfd) {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof(client_address);
// LT水平触发
#ifdef LT
            int connfd = accept(
                                listenfd, 
                                (struct sockaddr *)&client_address,
                                &client_addrlength
                                );
            if (connfd < 0) continue;
            if (http_conn::m_user_count >= MAXFD) {
                show_error(connfd, "Internal server busy");
                continue;
            }
            users[connfd].init(connfd, client_address);
#endif

// ET非阻塞边缘触发
#ifdef ET
            // 需要循环接收数据
            while (1) {
                int connfd = accept(
                                    listenfd, 
                                    (struct sockaddr *)&client_address, 
                                    &client_addrlength
                                   );
                if (connfd < 0) break;
                if (http_conn::m_user_count >= MAX_FD) {
                    show_error(connfd, "Internal server busy");
                    break;
                }
                users[connfd].init(connfd, client_address);
            }
            continue;
#endif
        }

        // 处理异常事件
        else if (events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){
            // 服务器关闭连接
        }

        // 处理信号
        else if ( (sockfd == pipefd[0]) && 
                  (events[i].events & EPOLLIN) )
        {
        }

        // 处理客户连接上接收的数据
        else if (events[i].events & EPOLLIN) {
            // 读入对应缓冲区
            if (users[sockfd].read_once()) 
                // 若监测到 读事件，该事件放入请求队列
                poll->append(users + sockfd);
            else 
                // 服务器关闭连接 
        }
    }
}