有限状态机实现解析HTTP报文

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>

#define BUFFER_SIZE 4096
// 主状态机状态(功能的选择)：正在分析请求行， 正在分析头部字段
enum CHECK_STATE
{
    CHECK_STATE_REQUESTLINE = 0,
    CHECK_STATE_HEADER
};
// 从状态机状态：读取到一个完整的行，行出错，行数据尚不完整
enum LINE_STATUS
{
    LINE_OK = 0,
    LINE_BAD,
    LINE_OPEN
};

// 服务器处理HTTP请求的结果：
// NO_REQUEST 表示请求不完整,需要继续读取客户数据
// GET_REQUEST 表示获得了一个完整的客户请求
// BAD_REQUEST 表示客户请求有语法错误
// FORBIDDEN_REQUEST 表示客户对资源没有足够的访问权限
// INTERNAL_ERROR 表示服务器内部错误
// CLOSED_CONNECTION 表示客户端已经关闭连接
enum HTTP_CODE
{
    NO_REQUEST,
    GET_REQUEST,
    BAD_REQUEST,
    FORBIDDEN_REQUEST,
    INTERNAL_ERROR,
    CLOSED_CONNECTION
};

// 根据服务器处理结果发送如下成功或失败的消息
static const char *szret[] = {"I got a correct resultn", "Something wrong"};

// 从状态机，用于解析出一行内容
LINE_STATUS parse_line(char *buffer, int &checked_index, int &read_index)
{
    char temp;
    // checked_index指向buffer（应用程序的读缓冲区）中当前正在分析的字节
    // read_index指向buffer中客户数据的尾部的下一字节
    // buffer 中第0~checked_index字节都已分析完毕，第checked_index ~ （read_index - 1）字节有下面的循环进行分析
    for (; checked_index < read_index; ++checked_index)
    {
        // 获得当前要分析的字节
        temp = buffer[checked_index];
        // 若当前字节是 回车符，说明可能读到一个完整的行
        if (temp == 'r')
        {
            // 若 "r"碰巧是目前buffer中最后一个已经被读入的客户数据，则这次分析没读到一个完整的行，返回LINE_OPEN表示还要继续读取客户数据才能进行下一步分析
            if ((checked_index + 1) == read_index)
            {
                return LINE_OPEN;
            }
            else if (buffer[checked_index + 1] == 'n')
            {
                // 若下一个字符是换行符，则表明成功读取到一个完整的行
                buffer[checked_index++] = '';
                buffer[checked_index++] = '';
                return LINE_OK;
            }
            return LINE_BAD;
        }
        else if (temp == 'n')
        { // 可能读到完整的行
            if ((checked_index > 1) && buffer[checked_index - 1] == 'r')
            {
                buffer[checked_index - 1] = '';
                buffer[checked_index++] = '';
            }
        }

        return LINE_BAD;
    }
}

// 分析请求行
HTTP_CODE parse_requestline(char *temp, CHECK_STATE &checkstate)
{
    // 检索第一个匹配' ' 或 't'的位置
    char *url = strpbrk(temp, " t"); 
    printf("url1 = %sn", url);
    if(!url) {
        return BAD_REQUEST;
    }
    *url++ = ''; // temp此时输出为GET

    char *method = temp; // 请求方法（如get post）
    printf("method:%sn", method);
    printf("url2 = %sn", url);
    // 
    if(strcasecmp(method, "GET") == 0)
    {
        printf("The request method is GETn");
    }
    else 
    {
        return BAD_REQUEST;
    }

    url += strspn(url, " t"); // 查找第一个不为 ' ' 且 't'的位置  
    printf("url3 = %sn", url);
    char *version = strpbrk(url, " t");
    printf("version = %sn", version);
    if(!version) 
    {
        return BAD_REQUEST;
    }
    *version++ = '';
    version += strspn(version, " t");
    printf("version2 = %sn", version);
    
    if(strcasecmp(version,  "HTTP/1.1") != 0) {
        return BAD_REQUEST;
    }

    // 检查URL是否合法
    if(strncasecmp(url, "http://", 7) == 0) {
        url += 7;
        url = strchr(url, '/');
    }

    if(!url || url[0]  !='/') {
        return BAD_REQUEST;
    }

    printf("The request URL is: %sn", url);

    // HTTP请求行处理完毕，状态转移到头部字段的分析
    checkstate = CHECK_STATE_HEADER;
    return NO_REQUEST;
}

// 分析头部字段
HTTP_CODE parse_headers(char *temp)
{
    // 遇到一个空行，说明得到了一个正确的HTTP请求
    if(temp[0] == '') 
    {
        return GET_REQUEST;
    }
    else if(strncasecmp(temp, "Host:", 5) == 0) //
    {
        temp += 5;
        // 跳过空格和制表符
        temp += strspn(temp, " t");
        printf("the reques host is:%sn", temp);
    }
    else
    {
        printf("I can not handle this headern");
    }
    return NO_REQUEST; // 请求不完整
}

// 分析http请求的入口函数
HTTP_CODE parse_content(char *buffer, int &checked_index, CHECK_STATE &checkstate,
                        int &read_index, int &start_line)
{
    LINE_STATUS linestatus = LINE_OK; // 记录当前行的【读取】状态
    HTTP_CODE retcode = NO_REQUEST; // 记录当前HTTP请求的处理结果
    // 主状态机，用于从buffer中取出所有完整的行 ???
    while((linestatus = parse_line(buffer, checked_index, read_index)) == LINE_OK) 
    {
        char *temp = buffer + start_line; // start_line是行在buffer中的起始位置
        start_line = checked_index; // 记录下一行的 起始位置
        switch (checkstate)
        {
            case CHECK_STATE_REQUESTLINE: // 分析请求行
            {
                retcode = parse_requestline(temp, checkstate);
                if(retcode == BAD_REQUEST) 
                {
                    return BAD_REQUEST;
                }
                break;
            }
            case CHECK_STATE_HEADER:    // 分析头部字段
            {
                retcode = parse_headers(temp);
                if(retcode == BAD_REQUEST) 
                {
                    return BAD_REQUEST;
                }
                else if(retcode == GET_REQUEST) 
                {
                    return GET_REQUEST;
                }
                break;
            }
            default:
            {
                return INTERNAL_ERROR;
            }
        }
    
    }

    // 若没有读取到一个完整的行，则表示还需要继续读取客户数据才能进一部分析
    if(linestatus == LINE_OPEN) 
    {
        return NO_REQUEST; // main收到这个返回会继续循环recv客户数据
    }
    else
    {
        return BAD_REQUEST;
    }
}

int main(int argc, char *argv[])
{
    if (argc <= 2)
    {
        printf("usage: %s ip_address port_numn", basename(argv[0]));
        return 1;
    }
    const char *ip = argv[1];
    int port = atoi(argv[2]);

    struct sockaddr_in addr;
    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &addr.sin_addr);
    addr.sin_port = htons(port);

    int listenfd = socket(PF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);

    int ret = bind(listenfd, (struct sockaddr *)&addr, sizeof(addr));
    assert(ret != -1);

    ret = listen(listenfd, 5);
    assert(ret != -1);

    struct sockaddr_in client;
    socklen_t client_addrlength = sizeof(client);
    int connfd = accept(listenfd, (struct sockaddr *)&client, &client_addrlength);
    if (connfd < 0)
    {
        printf("errno is: %sn", errno);
    }
    else
    {
        char buffer[BUFFER_SIZE];
        memset(buffer, '', BUFFER_SIZE);
        int data_read = 0;     // 记录每次recv读出的数据字节数
        int read_index = 0;    // 当前已经读取了多少字节的客户数据据
        int checked_index = 0; // 当前已分析完了多少字节的客户数据
        int start_line = 0;    // 行在buffer中的起始位置
        // 设置主状态机的初始状态,分析请求行
        CHECK_STATE checkstate = CHECK_STATE_REQUESTLINE;
        while (1)
        {
            data_read = recv(connfd, buffer + read_index, BUFFER_SIZE - read_index, 0);
            if (data_read == -1)
            {
                printf("reading failedn");
                break;
            }
            else if (data_read == 0)
            {
                printf("remote client has closed the connectionn");
                break;
            }
            read_index += data_read;
            // 分析目前已获得的所有客户数据
            HTTP_CODE result = parse_content(buffer, checked_index, checkstate, read_index, start_line);

            if (result == NO_REQUEST) // 请求不完整
            {
                continue;
            }
            else if (result == GET_REQUEST) // 请求正确且完整
            {
                send(connfd, szret[0], strlen(szret[0]), 0);
                break;
            }
            else 
            {
                send(connfd, szret[1], strlen(szret[1]), 0);
                break;
            }
            close(connfd);
        }
    }
    close(listenfd);
    return 0;
}