lighttpd1.4.18代码分析

converse

lighttpd1.4.18代码分析(八)--状态机(2)CON_STATE_READ状态

今天继续沿着状态转换序列图讲解状态机,这次到了CON_STATE_READ状态, 首先看看connection_state_machine函数部分的代码:

1. 
   
2. // 读            
   
3.         case CON_STATE_READ_POST:
   
4.         case CON_STATE_READ:
   
5.             if (srv->srvconf.log_state_handling) {
   
6.                 log_error_write(srv, __FILE__, __LINE__, "sds",
   
7.                         "state for fd", con->fd, connection_get_state(con->state));
   
8.             }
   
9. 
   
10.             connection_handle_read_state(srv, con);
    
11.             break;
    

复制代码

可以看到,CON_STATE_READ_POST状态和CON_STATE_READ状态调用的同一段代码,不过我们今天讲解的CON_STATE_READ状态,CON_STATE_READ_POST状态在后面讲解.

上面的代码调用了connection_handle_read_state函数,进入这个函数内部,分为几个部分进行分析:

1. 
   
2. if (con->is_readable) {
   
3.         con->read_idle_ts = srv->cur_ts;
   
4. 
   
5.         // -1:出错 -2:对方关闭连接 0:成?
   
6.         switch(connection_handle_read(srv, con)) {
   
7.         case -1:
   
8.             return -1;
   
9.         case -2:
   
10.             is_closed = 1;
    
11.             break;
    
12.         default:
    
13.             break;
    
14.         }
    
15.     }
    

复制代码

这里调用函数connection_handle_read, 来看看这个函数的实现:

1. 
   
2. // -1:出错 -2:对方关闭连接 0:成功
   
3. static int connection_handle_read(server *srv, connection *con) {
   
4.     int len;
   
5.     buffer *b;
   
6.     int toread;
   
7. 
   
8.     if (con->conf.is_ssl) {
   
9.         return connection_handle_read_ssl(srv, con);
   
10.     }
    
11. 
    
12. #if defined(__WIN32)
    
13.     b = chunkqueue_get_append_buffer(con->read_queue);
    
14.     buffer_prepare_copy(b, 4 * 1024);
    
15.     len = recv(con->fd, b->ptr, b->size - 1, 0);
    
16. #else
    
17.     // 获取有多少数据可读
    
18.     if (ioctl(con->fd, FIONREAD, &toread)) {
    
19.         log_error_write(srv, __FILE__, __LINE__, "sd",
    
20.                 "unexpected end-of-file:",
    
21.                 con->fd);
    
22.         return -1;
    
23.     }
    
24.     // 根据数据量准备缓冲区
    
25.     b = chunkqueue_get_append_buffer(con->read_queue);
    
26.     buffer_prepare_copy(b, toread + 1);
    
27.     // 读数据
    
28.     len = read(con->fd, b->ptr, b->size - 1);
    
29. #endif
    
30. 
    
31.     if (len < 0) {
    
32.         con->is_readable = 0;
    
33. 
    
34.         // Non-blocking  I/O has been selected using O_NONBLOCK and no data
    
35.         // was immediately available for reading.
    
36.         if (errno == EAGAIN)
    
37.             return 0;
    
38.         if (errno == EINTR) {
    
39.             /* we have been interrupted before we could read */
    
40.             con->is_readable = 1;
    
41.             return 0;
    
42.         }
    
43. 
    
44.         if (errno != ECONNRESET) {
    
45.             /* expected for keep-alive */
    
46.             log_error_write(srv, __FILE__, __LINE__, "ssd", "connection closed - read failed: ", strerror(errno), errno);
    
47.         }
    
48. 
    
49.         connection_set_state(srv, con, CON_STATE_ERROR);
    
50. 
    
51.         return -1;
    
52.     } else if (len == 0) {
    
53.         // 当读入数据 = 0时 表示对端关闭了连接
    
54.         con->is_readable = 0;
    
55.         /* the other end close the connection -> KEEP-ALIVE */
    
56. 
    
57.         /* pipelining */
    
58. 
    
59.         return -2;
    
60.     } else if ((size_t)len < b->size - 1) {
    
61.         /* we got less then expected, wait for the next fd-event */
    
62. 
    
63.         con->is_readable = 0;
    
64.     }
    
65. 
    
66.     // 记录读入的数据量 未使用的数据第一个字节为0
    
67.     b->used = len;
    
68.     b->ptr[b->used++] = '\0';
    
69. 
    
70.     con->bytes_read += len;
    
71. #if 0
    
72.     dump_packet(b->ptr, len);
    
73. #endif
    
74. 
    
75.     return 0;
    
76. }
    

复制代码

简单的说, 该函数首先调用ioctl获取fd对应的缓冲区中有多少可读的数据, 然后调用chunkqueue_get_append_buffer和buffer_prepare_copy函数准备好所需的缓冲区, 准备好缓冲区之后, 调用read函数读取缓冲区中的数据.对read函数的调用结果进行区分, 小于0表示出错, 返回-1;等于0表示关闭了连接, 返回-2;假如读取的数据长度比预期的小, 那么就等待下一次继续读数据, 最后将已经读入的数据缓冲区最后一个字节置'\0',返回0.

继续回到函数connection_handle_read_state中, 看接下来的代码:

1. 
   
2. // 这一段循环代码用于更新read chunk队列,没有使用的chunk都归入未使用chunk链中
   
3.     /* the last chunk might be empty */
   
4.     for (c = cq->first; c;) {
   
5.         if (cq->first == c && c->mem->used == 0) {
   
6.             // 如果第一个chunk是空的并且没有使用过
   
7.             /* the first node is empty */
   
8.             /*  and it is empty, move it to unused */
   
9. 
   
10.             // 则chunk队列的第一个chunk为下一个chunk
    
11.             cq->first = c->next;
    
12.             // 第一个chunk为NULL, 那么最后一个chunk为NULL
    
13.             if (cq->first == NULL)
    
14.                 cq->last = NULL;
    
15. 
    
16.             // 更新chunk队列中对于未使用chunk的记录
    
17.             c->next = cq->unused;
    
18.             cq->unused = c;
    
19.             cq->unused_chunks++;
    
20. 
    
21.             // 重新指向第一个chunk
    
22.             c = cq->first;
    
23.         } else if (c->next && c->next->mem->used == 0) {
    
24.             chunk *fc;
    
25.             // 如果下一个chunk存在而且未使用过
    
26.             /* next node is the last one */
    
27.             /*  and it is empty, move it to unused */
    
28. 
    
29.             // 将这个chunk从队列中分离出去, 同时fc指向这个未使用的chunk
    
30.             fc = c->next;
    
31.             c->next = fc->next;
    
32. 
    
33.             // 将这个未使用的chunk(fc所指)保存到未使用chunk链中
    
34.             fc->next = cq->unused;
    
35.             cq->unused = fc;
    
36.             cq->unused_chunks++;
    
37. 
    
38.             /* the last node was empty */
    
39.             // 如果c的下一个chunk是空的, 那么chunk队列的最后一个chunk就是c了
    
40.             if (c->next == NULL) {
    
41.                 cq->last = c;
    
42.             }
    
43. 
    
44.             // 继续往下走
    
45.             c = c->next;
    
46.         } else {
    
47.             // 继续往下走
    
48.             c = c->next;
    
49.         }
    
50.     }
    

复制代码

每个connection结构体中, 有一个read_queue成员, 该成员是chunkqueue类型的, 一个connection读入的数据都会保存在这个成员中, 由于一直没有详细介绍chunkqueue结构体及其使用, 这里不对上面的过程进行详细的分析, 只需要知道chunkqueue结构体内部使用的是链表保存数据, 上面这段代码遍历这个链表, 将未使用的部分抽取下来放到未使用chunkqueue中.

继续看下面的代码, 下面的代码根据状态是CON_STATE_READ还是CON_STATE_READ_POST进行了区分, 同样的,目前仅关注CON_STATE_READ状态部分:

1. 
   
2.   case CON_STATE_READ:    // 如果是可读状态
   
3.         /* if there is a \r\n\r\n in the chunkqueue
   
4.          *
   
5.          * scan the chunk-queue twice
   
6.          * 1. to find the \r\n\r\n
   
7.          * 2. to copy the header-packet
   
8.          *
   
9.          */
   
10. 
    
11.         last_chunk = NULL;
    
12.         last_offset = 0;
    
13. 
    
14.         // 遍历read chunk队列
    
15.         for (c = cq->first; !last_chunk && c; c = c->next) {
    
16.             buffer b;
    
17.             size_t i;
    
18. 
    
19.             b.ptr = c->mem->ptr + c->offset;
    
20.             b.used = c->mem->used - c->offset;
    
21. 
    
22.             // 遍历当前chunk中的每一个字符
    
23.             for (i = 0; !last_chunk && i < b.used; i++) {
    
24.                 char ch = b.ptr[i];
    
25.                 size_t have_chars = 0;
    
26. 
    
27.                 // 判断当前字符
    
28.                 switch (ch) {
    
29.                 case '\r':        // 如果当前字符是'\r'
    
30.                     /* we have to do a 4 char lookup */
    
31.                     // 该chunk还剩余多少个字符
    
32.                     have_chars = b.used - i - 1;
    
33.                     
    
34.                     if (have_chars >= 4) {
    
35.                         // 如果当前剩余字符大于等于4, 判断紧跟着的4个字符是不是"\r\n\r\n", 如果是就退出循环
    
36.                         /* all chars are in this buffer */
    
37. 
    
38.                         if (0 == strncmp(b.ptr + i, "\r\n\r\n", 4)) {
    
39.                             /* found */
    
40.                             last_chunk = c;
    
41.                             last_offset = i + 4;
    
42. 
    
43.                             break;
    
44.                         }
    
45.                     } else {
    
46.                         // 否则就去查看下一个chunk, 看看是不是和这个chunk一起形成了"\r\n\r\n"
    
47.                         chunk *lookahead_chunk = c->next;
    
48.                         size_t missing_chars;
    
49.                         /* looks like the following chars are not in the same chunk */
    
50. 
    
51.                         missing_chars = 4 - have_chars;
    
52. 
    
53.                         if (lookahead_chunk && lookahead_chunk->type == MEM_CHUNK) {
    
54.                             /* is the chunk long enough to contain the other chars ? */
    
55. 
    
56.                             if (lookahead_chunk->mem->used > missing_chars) {
    
57.                                 if (0 == strncmp(b.ptr + i, "\r\n\r\n", have_chars) &&
    
58.                                     0 == strncmp(lookahead_chunk->mem->ptr, "\r\n\r\n" + have_chars, missing_chars)) {
    
59. 
    
60.                                     last_chunk = lookahead_chunk;
    
61.                                     last_offset = missing_chars;
    
62. 
    
63.                                     break;
    
64.                                 }
    
65.                             } else {
    
66.                                 /* a splited \r \n */
    
67.                                 break;
    
68.                             }
    
69.                         }
    
70.                     }
    
71. 
    
72.                     break;
    
73.                 }
    
74.             }
    
75.         }
    

复制代码

这段代码用于在读入数据中查找"\r\n\r\n",熟悉http协议的人知道, 这代表着一个http请求的结束,也就是说, 上面的代码用于判断是否已经接受了一个完整的http请求.但是有一个细节部分需要注意, 前面说过chunkqueue内部是使用一个链表来存放数据,比方说这个链表中有两个节点, 一个节点存放一字节的数据, 一个节点存放了十字节的数据,这时候可能会出现这样的情况:假如在一个节点存放的数据中找到了字符'\r',而该节点剩下的数据不足以存放"\r\n\r \n"字符串剩余的字符, 也就是说, 不足4个字节, 那么查找"\r\n\r\n"的过程就要延续到下一个节点继续进行查找.比如在一个节点中最后部分找到了"\r", 那么就要在下一个节点的数据起始位置中查找"\n\r\n".

继续看下面的代码:

1. 
   
2.        /* found */
   
3.         // 读取到了请求的结尾, 现在将请求字符串放到request字段中
   
4.         if (last_chunk) {
   
5.             buffer_reset(con->request.request);
   
6. 
   
7.             for (c = cq->first; c; c = c->next) {
   
8.                 buffer b;
   
9. 
   
10.                 b.ptr = c->mem->ptr + c->offset;
    
11.                 b.used = c->mem->used - c->offset;
    
12. 
    
13.                 if (c == last_chunk) {
    
14.                     b.used = last_offset + 1;
    
15.                 }
    
16. 
    
17.                 buffer_append_string_buffer(con->request.request, &b);
    
18. 
    
19.                 if (c == last_chunk) {
    
20.                     c->offset += last_offset;
    
21. 
    
22.                     break;
    
23.                 } else {
    
24.                     /* the whole packet was copied */
    
25.                     c->offset = c->mem->used - 1;
    
26.                 }
    
27.             }
    
28. 
    
29.             // 设置状态为读取请求结束
    
30.             connection_set_state(srv, con, CON_STATE_REQUEST_END);
    
31.         } else if (chunkqueue_length(cq) > 64 * 1024) {
    
32.             // 读入的数据太多, 出错
    
33.             log_error_write(srv, __FILE__, __LINE__, "s", "oversized request-header -> sending Status 414");
    
34. 
    
35.             con->http_status = 414; /* Request-URI too large */
    
36.             con->keep_alive = 0;
    
37.             connection_set_state(srv, con, CON_STATE_HANDLE_REQUEST);
    
38.         }
    
39.         break;
    

复制代码

如果前面查找到了"\r\n\r\n", 那么函数就进入这个部分.这部分代码做的事情就是复制http请求头到connection结构体中request成员中.需要注意的是如果没有查找到"\r\n\r\n",并且缓冲区数据长度大于64*1024, 也就是64K字节, 那么就返回414错误, 也就是说, 对于lighttpd而言, 一般的http请求不能超过64K字节.

这个过程就分析到这里,简单的总结一下:首先从缓冲区中读取数据, 然后查找"\r\n\r\n"字符串, 判断是否已经读取了完整的http请求, 如果是的话就复制下来, 最后进入CON_STATE_REQUEST_END状态, 这是下一节分析的内容.

Cyberman.Wu

原帖由 converse 于 2008-9-24 10:30 发表
抱歉,不会用kqueue,因为我没用过BSD,不能给你什么提示了.

今天下午测试了一下kqueue，看到man里说它不能被fork所继承，仔细看了一下代码大概明白了一点，它是在init中关闭，然后在reset中再重新创建。

fly6

mark
支持楼主

boywonder

看到这里是否要对http协议了解一下会好懂一些？如果要看的话是不是就看http的RFC就可以了？
之前稍微看过一些rfc文档，看的云里雾里的，都不知道里面在讲什么

[ 本帖最后由 boywonder 于 2008-9-25 14:43 编辑 ]

converse

应该有一点http协议的基础,其实我也不是特别熟悉http协议,都是一边看代码一边看协议.

chary8088

关注。。。学习

027xiatian

分析得太棒了！！！！
学习..

libin1983

keyvalue.c 中有个 keyvalue_buffer, 用 grep 没查到定义的地方...

libin1983

原帖由 libin1983 于 2008-9-27 12:22 发表
keyvalue.c 中有个 keyvalue_buffer, 用 grep 没查到定义的地方...

找到了:

1. 
   
2. #define KVB(x) \
   
3. typedef struct {\
   
4.         x **kv; \
   
5.         size_t used;\
   
6.         size_t size;\
   
7. } x ## _buffer
   
8. 
   
9. KVB(keyvalue);
   
10. KVB(s_keyvalue);
    
11. KVB(httpauth_keyvalue);
    
12. KVB(pcre_keyvalue);
    

复制代码

KVB(keyvalue);
展开变成了:

1. 
   
2. typedef struct {\
   
3.         keyvalue **kv; \
   
4.         size_t used;\
   
5.         size_t size;\
   
6. } keyvalue_buffer
   

复制代码

converse

这又是因为lighttpd中大量使用宏,造成了阅读上的障碍.它这一点,我挺不认同的.