1
#include "http_conn.h" // 这是我们写好的头文件
2

3
#include <mysql/mysql.h> // MySQL C/C++ 客户端库的头文件
4
#include <fstream> // C++ 标准库中的文件输入输出相关操作的头文件

1
//初始化连接,外部调用初始化套接字地址
2
/*
3
init()函数的参数：
4
sockfd：套接字文件描述符
5
addr：套接字地址结构体
6
root：网站根目录
7
TRIGMode：触发模式
8
close_log：是否关闭日志
9
user：数据库用户名
10
passwd：数据库密码
11
sqlname：数据库名
12
*/
13
void http_conn::init(int sockfd, const sockaddr_in &addr, char *root, int TRIGMode,
14
                     int close_log, string user, string passwd, string sqlname)
15
{
16
    // 将套接字文件描述符和套接字地址存到该 http 连接对象的成员变量中
17
    m_sockfd = sockfd;
18
    m_address = addr;
19
  // 调用 addfd() 函数，将套接字文件描述符添加到指定的 epoll 实例中，
20
    // 以便进行事件监听，具体介绍在epoll相关代码部分
21
    addfd(m_epollfd, sockfd, true, m_TRIGMode);
22
    // 增加用户数统计
23
    m_user_count++;
24

25
    //当浏览器出现连接重置时，可能是网站根目录出错或http响应格式出错或者访问的文件中内容完全为空
26
    // 设置网站根目录路径
27
    doc_root = root;
28
    // 保存传入的触发模式和关闭日志的选项值
29
    m_TRIGMode = TRIGMode;
30
    m_close_log = close_log;
31
  // 将传入的数据库用户名、密码、数据库名拷贝到相应的成员变量中
32
    strcpy(sql_user, user.c_str());
33
    strcpy(sql_passwd, passwd.c_str());
34
    strcpy(sql_name, sqlname.c_str());
35
  // 调用无参的 init() 函数进行进一步的初始化
36
    init();
37
}

1
//初始化新接受的连接
2
//check_state默认为分析请求行状态
3
void http_conn::init()
4
{
5
    mysql = NULL;
6
    bytes_to_send = 0;
7
    bytes_have_send = 0;
8
    m_check_state = CHECK_STATE_REQUESTLINE;
9
    m_linger = false;
10
    m_method = GET;
11
    m_url = 0;
12
    m_version = 0;
13
    m_content_length = 0;
14
    m_host = 0;
15
    m_start_line = 0;
16
    m_checked_idx = 0;
17
    m_read_idx = 0;
18
    m_write_idx = 0;
19
    cgi = 0;
20
    m_state = 0;
21
    timer_flag = 0;
22
    improv = 0;
23

24
    memset(m_read_buf, '\0', READ_BUFFER_SIZE);
25
    memset(m_write_buf, '\0', WRITE_BUFFER_SIZE);
26
    memset(m_real_file, '\0', FILENAME_LEN);
27
}

1
// 循环读取客户数据，直到无数据可读或对方关闭连接
2
// 非阻塞 ET 工作模式下，需要一次性将数据读完
3
bool http_conn::read_once() {
4
  // 读缓冲区大小 READ_BUFFER_SIZE 不够大，直接返回 false
5
  if (m_read_idx >= READ_BUFFER_SIZE) {
6
    return false;
7
  }
8
  // 初始化读取字节数为 0
9
  int bytes_read = 0;
10

11
  // LT 读取数据，持续通知，有可读时内核会持续通知应用程序直到数据被处理完
12
  if (0 == m_TRIGMode) {
13
        /*
14
        recv() 函数：
15
        参数：
16
        使用 recv() 函数从套接字文件描述符 m_sockfd 对应套接字的缓冲区
17
        中读取数据；
18
        并将这些数据存储到读缓冲区 m_read_buf + m_read_idx
19
        以后，在 m_read_idx 以前已经有数据了，读缓冲区的数据结构是数组；
20
        第三个参数指的是读缓冲区原长度减掉已经存储的长度，因为 m_read_idx
21
        是读缓冲区读取数据的最后一个字节的下一个位置；
22
        第四个参数置为 0， 说明接收操作设置为默认；
23

24
        返回值：
25
        成功收到数据，返回读取到的字节数；
26
        连接已关闭，返回 0；
27
        出现错误，返回 -1，并将错误码存到 errno 里
28

29
        附加解释：
30
        recv() 函数为阻塞函数，没有数据接收时，它会一直等待数据到达，直到
31
        超时或出现错误；但是不代表recv()不能非阻塞式读取
32
        */
33
    bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
34
    m_read_idx += bytes_read; // 更新读缓冲区数据末尾的下标
35
    // 如果连接已关闭（0）或发生错误（-1），返回 false
36
    if (bytes_read <= 0) {
37
      return false;
38
    }
39

40
    return true;
41
  }
42
  // ET 读取数据，边缘触发，只在状态变化时通知应用程序，
43
    // 如果应用程序没有读完所有数据，不会重复通知，所以要一次性读完
44
  else {
45
    while (true) {
46
            // 与上面一样，使用阻塞函数 recv() 读取数据
47
      bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
48
            // 如果发生错误
49
      if (bytes_read == -1) {
50
                // 没有可用数据，说明已经处理完所有数据了，退出循环
51
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
52
          break;
53
        }
54
                // 不是EAGAIN和EWOULDBLOCK的话，发生别的错误，返回 false
55
        return false;
56
      }
57
      else if (bytes_read == 0) { // 为 0， 连接已关闭，返回 false
58
        return false;
59
      }
60
            // 没发生错误也没关闭连接，正确的读取了数据，更新读缓冲区结尾下标
61
      m_read_idx += bytes_read;
62
    }
63
    return true;
64
  }
65
}

1
#include <sys/socket.h>
2
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

1
//m_start_line是行在buffer中的起始位置，将该位置后面的数据赋给text
2
//此时从状态机已提前将一行的末尾字符\r\n变为\0\0，所以text可以直接取出完整的行进行解析
3
char* get_line(){
4
    return m_read_buf+m_start_line;
5
}
6

7
http_conn::HTTP_CODE http_conn::process_read()
8
{
9
    // 初始化从状态机状态、HTTP请求的解析结果
10
    LINE_STATUS line_status = LINE_OK; // 完整读取一行
11
    HTTP_CODE ret = NO_REQUEST; // 请求不完整，需要继续读取请求报文
12
    char *text = 0;
13

14
    // 这里写的两个判断条件在主状态机逻辑中会讲解
15
    // 循环读取并解析请求，parse_line() 为从状态机的具体实现
16
    while ((m_check_state == CHECK_STATE_CONTENT && line_status == LINE_OK) || ((line_status = parse_line()) == LINE_OK))
17
    {
18
        text = get_line();  // 获取当前行的文本
19
        // m_start_line 是每一个数据行在 m_read_buf 中的起始位置
20
        // m_checked_idx 表示从状态机在 m_read_buf 中读取的位置
21
        m_start_line = m_checked_idx;
22
        LOG_INFO("%s", text);  // 打印日志，记录请求内容
23

24
        // 根据当前检查状态和解析的文本进行不同的处理
25
        // 主状态机的三种状态转移逻辑：请求行，请求头，请求体
26
        switch (m_check_state)
27
        {
28
        case CHECK_STATE_REQUESTLINE:
29
        {
30
            // 解析请求行函数，返回值为解析状态 HTTP_CODE
31
            ret = parse_request_line(text);
32
            // 请求行语法错误，返回该解析状态
33
            if (ret == BAD_REQUEST)
34
                return BAD_REQUEST;
35
            break;
36
        }
37
        case CHECK_STATE_HEADER:
38
        {
39
            // 解析请求头函数，返回值为解析状态 HTTP_CODE
40
            ret = parse_headers(text);
41
            // 请求头语法错误，返回该解析状态
42
            if (ret == BAD_REQUEST)
43
                return BAD_REQUEST;
44
            // 完整解析 GET 请求后，跳转到报文响应函数 do_request()
45
            else if (ret == GET_REQUEST)
46
            {
47
                return do_request();
48
            }
49
            break;
50
        }
51
        case CHECK_STATE_CONTENT:
52
        {
53
            // 解析请求体
54
            ret = parse_content(text);
55

56
            // 完整解析 POST 请求后，跳转到报文响应函数 do_request()
57
            if (ret == GET_REQUEST)
58
                return do_request();
59
            // 解析完请求体就解析完请求报文了，更新 line_status，避免再次进入循环
60
            line_status = LINE_OPEN; // 读取的行不完整，当 line_status 为完整读取一行 LINE_OK 时才进入循环
61
            break;
62
        }
63
        default:
64
            return INTERNAL_ERROR; // 未知检查状态
65
        }
66
    }
67

68
    return NO_REQUEST;
69
}

1
http_conn::HTTP_CODE http_conn::do_request()
2
{
3
    // 将文件根目录复制到m_real_file中
4
    strcpy(m_real_file, doc_root);
5
    int len = strlen(doc_root);
6

7
    const char *p = strrchr(m_url, '/');  // 找到最后一个斜杠的位置
8

9
    // 处理cgi请求
10
    if (cgi == 1 && (*(p + 1) == '2' || *(p + 1) == '3'))
11
    {
12
        // 根据标志判断是登录检测还是注册检测
13
        char flag = m_url[1];
14

15
        // 分配足够大的空间来存储真实的URL
16
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
17
        strcpy(m_url_real, "/");
18
        strcat(m_url_real, m_url + 2);
19
        strncpy(m_real_file + len, m_url_real, FILENAME_LEN - len - 1);
20
        free(m_url_real);
21

22
        // 提取用户名和密码
23
        // user = 123 && passwd = 123
24
        char name[100], password[100];
25
        int i;
26
        for (i = 5; m_string[i] != '&'; ++i)
27
            name[i - 5] = m_string[i];
28
        name[i - 5] = '\0';
29

30
        int j = 0;
31
        for (i = i + 10; m_string[i] != '\0'; ++i, ++j)
32
            password[j] = m_string[i];
33
        password[j] = '\0';
34

35
        if (*(p + 1) == '3')
36
        {
37
            // 如果是注册，先检测数据库中是否有重名的
38
            // 没有重名的，进行增加数据
39
            char *sql_insert = (char *)malloc(sizeof(char) * 200);
40
            strcpy(sql_insert, "INSERT INTO user(username, passwd) VALUES(");
41
            strcat(sql_insert, "'");
42
            strcat(sql_insert, name);
43
            strcat(sql_insert, "', '");
44
            strcat(sql_insert, password);
45
            strcat(sql_insert, "')");
46

47
            if (users.find(name) == users.end())
48
            {
49
                m_lock.lock();
50
                int res = mysql_query(mysql, sql_insert);
51
                users.insert(pair<string, string>(name, password));
52
                m_lock.unlock();
53

54
                if (!res)
55
                    strcpy(m_url, "/log.html");
56
                else
57
                    strcpy(m_url, "/registerError.html");
58
            }
59
            else
60
                strcpy(m_url, "/registerError.html");
61
        }
62
        // 如果是登录，直接判断
63
        // 若浏览器端输入的用户名和密码在表中可以查找到，返回1，否则返回0
64
        else if (*(p + 1) == '2')
65
        {
66
            // 如果是登录
67
            if (users.find(name) != users.end() && users[name] == password)
68
                strcpy(m_url, "/welcome.html");  // 登录成功
69
            else
70
                strcpy(m_url, "/logError.html");  // 登录失败
71
        }
72
    }
73

74
    // 处理其他请求
75
    if (*(p + 1) == '0')
76
    {
77
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
78
        strcpy(m_url_real, "/register.html");
79
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
80

81
        free(m_url_real);
82
    }
83
    else if (*(p + 1) == '1')
84
    {
85
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
86
        strcpy(m_url_real, "/log.html");
87
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
88

89
        free(m_url_real);
90
    }
91
    else if (*(p + 1) == '5')
92
    {
93
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
94
        strcpy(m_url_real, "/picture.html");
95
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
96

97
        free(m_url_real);
98
    }
99
    else if (*(p + 1) == '6')
100
    {
101
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
102
        strcpy(m_url_real, "/video.html");
103
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
104

105
        free(m_url_real);
106
    }
107
    else if (*(p + 1) == '7')
108
    {
109
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
110
        strcpy(m_url_real, "/fans.html");
111
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
112

113
        free(m_url_real);
114
    }
115
    else
116
        strncpy(m_real_file + len, m_url, FILENAME_LEN - len - 1);
117

118
    // 检查文件状态
119
    if (stat(m_real_file, &m_file_stat) < 0)
120
        return NO_RESOURCE;
121

122
    if (!(m_file_stat.st_mode & S_IROTH))
123
        return FORBIDDEN_REQUEST;
124

125
    if (S_ISDIR(m_file_stat.st_mode))
126
        return BAD_REQUEST;
127

128
    // 打开文件并将其映射到内存
129
    int fd = open(m_real_file, O_RDONLY);
130
    m_file_address = (char *)mmap(0, m_file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
131
    close(fd);
132

133
    return FILE_REQUEST;
134
}

1
//解析http请求的一个头部信息
2
http_conn::HTTP_CODE http_conn::parse_headers(char *text)
3
{
4
    // 判断是空行还是请求头
5
    // 首字符为\0说明是空行
6
    if (text[0] == '\0')
7
    {
8
        // 通过读取请求体长度来判断是GET还是POST请求
9
        // m_content_length：post请求体长度
10
        if (m_content_length != 0)
11
        {
12
            // POST需要跳转到请求体处理状态
13
            m_check_state = CHECK_STATE_CONTENT;
14
            return NO_REQUEST; // 请求不完整，需要继续读取请求报文数据
15
        }
16
        return GET_REQUEST; // 获得完整的HTTP请求
17
    }
18
    // 解析请求头连接字段
19
    // strncasecmp()：比较字符串前n个字符，不区分大小写，相等返回0
20
    else if (strncasecmp(text, "Connection:", 11) == 0)
21
    {
22
        text += 11; // 跳过“Connection:”字符串
23

24
        // 跳过空格和制表符
25
        // strspn()：返回str1中第一个没有出现在str2中字符的位置，实现跳过空格或制表符
26
        text += strspn(text, " \t");
27
        // strcasecmp()：比较字符串，相等返回0
28
        if (strcasecmp(text, "keep-alive") == 0)
29
        {
30
            // 如果是长连接，则将linger标志设置为true
31
            m_linger = true;
32
        }
33
    }
34
    // 解析请求体内容长度字段
35
    // // strncasecmp()：比较字符串前n个字符，不区分大小写，相等返回0
36
    else if (strncasecmp(text, "Content-length:", 15) == 0)
37
    {
38
        text += 15; // 跳过"Content-length:"字符串
39
        // strspn()：返回str1中第一个没有出现在str2中字符的位置，实现跳过空格或制表符
40
        text += strspn(text, " \t");
41
        // 将请求体长度保存到m_content_length变量中
42
        // atol()：字符串中连续数字转长整型，遇到字符结束，后面的数字就不算了，返回长整型数字，如果没有数字返回0
43
        m_content_length = atol(text); // 取请求体长度
44
    }
45
    // 解析请求头HOST字段
46
    // strncasecmp()：比较字符串前n个字符，不区分大小写，相等返回0
47
    else if (strncasecmp(text, "Host:", 5) == 0)
48
    {
49
        text += 5; // 跳过"Host:"字符串
50
        // strspn()：返回str1中第一个没有出现在str2中字符的位置，实现跳过空格或制表符
51
        text += strspn(text, " \t");
52
        m_host = text; // 将主机名保存到m_host变量中
53
    }
54
    else
55
    {
56
        LOG_INFO("oop!unknow header: %s", text);
57
        // 如果无法识别该头部，则打印日志提示
58
    }
59
    return NO_REQUEST; // 请求不完整，需要继续读取请求报文数据
60
}