Lighttpd中发送index.html的流程

最新推荐文章于 2023-09-10 00:04:00 发布

lieye_leaves

最新推荐文章于 2023-09-10 00:04:00 发布

阅读量4.6k

点赞数

分类专栏： net/tcp/ip专题

net/tcp/ip专题专栏收录该内容

16 篇文章 3 订阅

订阅专栏

Lighttpd中发送index.html的流程

——以请求首页为例分析lighttpd处理HTTP请求的流程

http://bbs.chinaunix.net/thread-1640195-1-1.html

一．概述

lighttpd代码版本号为1.4.22，lighttpd只配置了index.html其它的什么都没有。发送请求http://192.168.1.14:80请求到lighttpd的时候，lighttpd会返回首页内容。

具体配置如下，一共有四个文件可供选择，
在配置文件lighttpd.conf中有一项
index-file.names += (

"index.xhtml", "index.html", "index.htm", "default.htm", "index.php"

)

同时在文件lighttpd.conf中配置index.html的路径如下：

server.document-root = "/home/lighttpd/www"

启动时如下：./lighttpd -D -f /etc/lighttpd/lighttpd.conf

另外还需要提到的是lighttpd加载的模块， lighttpd在启动加载模块的时候会加载三个默认模块：mod_indexfile,mod_dirlisting,mod_staticfile。

二．代码解析

2.1 解析HTTP请求

本文直接从connection_state_machine讲起。http_request_parse解析HTTP请求，然后将状态置为CON_STATE_HANDLE_REQUEST。http_request_parse函数位于request.c当中。这个函数比较长，有接近一千行的规模，这个函数由两个循环构成：
第一循环的作用是获取HTTP协议版本号，HTTP请求类型，请求的URI，并且会检查HTTP版本是否合法，URI是否含有非法字符。处理的流程是，寻找第一行中的空格，如果找到第一个空格，那么空格前的字符串为请求类型，记下当前位置。寻找第一行中的第二个空格，如果找到，那么空格前从上一个位置起的字符串为URI，这代表要请求的资源。如果在第一行中找到第三个空格，这代表出错了。

1. 496 case ' ':

2. 497 switch(request_line_stage) {

3. 498 case 0:

4. 499 /* GET|POST|... */

5. 500 method = con->parse_request->ptr + first;

6. 501 first = i + 1;

7. 502 break;

8. 503 case 1:

9. 504 /* /foobar/... */

10. 505 uri = con->parse_request->ptr + first;

11. 506 first = i + 1;

12. 507 break;

13. 508 default:

14. 509 /* ERROR, one space to much */

15. 510 con->http_status = 400;

16. 511 con->response.keep_alive = 0;

17. 512 con->keep_alive = 0;

18. 513

19. 514 if (srv->srvconf.log_request_header_on_error) {

20. 515 log_error_write(srv, __FILE__, __LINE__, "s", "overlong request line -> 400");

21. 516 log_error_write(srv, __FILE__, __LINE__, "Sb",

22. 517 "request-header:\n",

23. 518 con->request.request);

24. 519 }

25. 520 return 0;

26. 521 }

27. 522

28. 523 request_line_stage++; //注意这一行

29. 524 break;

下一步是找到表示行结束的\r\n。

1. switch(*cur) {

2. 324 case '\r':

3. 325 if (con->parse_request->ptr[i+1] == '\n') {

4. 330 /* \r\n -> \0\0 */

5. 331 con->parse_request->ptr[i] = '\0';

6. 332 con->parse_request->ptr[i+1] = '\0';

7. ....

8. 349

9. 350 proto = con->parse_request->ptr + first;

10. 351

11. 352 *(uri - 1) = '\0'; //　确定URI

12. 353 *(proto - 1) = '\0';　//确定协议

13. ...

14. 371 con->request.http_method = r; //确定请求类型,为GET

15. ...

16. 487 buffer_copy_string_buffer(con->request.orig_uri, con->request.uri);

17. 488

18. 489 con->http_status = 0;

19. 490

20. 491 i++;

21. 492 line++; //　注意这一行，如果执行到这里，下轮for循环就退出

22. 493 first = i+1;

23. 494 }

24. 495 break;

第二个循环的作用是取HTTP头，同时还检查是否有非法字符。处理的流程是，先寻找：号，这个是分隔符，用来分隔头名称和值。代码中分别使用key和value来表示，另外使用is_key这个变量来表示是否已经找到了key。代码分为if(is_key) ... else 两块。is_key的初始值为1，所以代码一开始进入的是if(is_key)的部分，一直到下面的代码。

1. 558 case ':':

2. 559 is_key = 0;

3. 560

4. 561 value = cur + 1;

5. 562

6. 563 if (is_ws_after_key == 0) {

7. 564 key_len = i - first;

8. 565 }

9. 566 is_ws_after_key = 0;

10. 567

11. 568 break;

复制代码

如果找到了:号，下一次循环进入的就是else部分了。这里说的只是正常情况，如果出错了或者有异常的话，就退出了。再看看else部分里的代码。

1. 760 int s_len;

2. 761 key = con->parse_request->ptr + first; //取得key

3. 762

4. 763 s_len = cur - value;

5. 764

6. 765 /* strip trailing white-spaces */

7. 766 for (; s_len > 0 &&

8. 767 (value[s_len - 1] == ' ' ||

9. 768 value[s_len - 1] == '\t'); s_len--);

10. 769

11. 770 value[s_len] = '\0'; //取得value

12. 771

复制代码

如果一行结束了，就把key和value存起来。

1. 772 if (s_len > 0) {

2. 773 int cmp = 0;

3. 774 if (NULL == (ds = (data_string *)array_get_unused_element(con->request.headers, TYPE_STRING))) {

4. 775 ds = data_string_init();

5. 776 }

6. 777 buffer_copy_string_len(ds->key, key, key_len);

7. 778 buffer_copy_string_len(ds->value, value, s_len);

9. 把取到的HTTP头加入队列中。然后再对几个头做一些处理，"Connection", "Content-Length","Content-Type","Expect","Host","If-Modified-Since"等等……最后做一下初始化，进入下一轮循环。

10. [code]

11. 996 i++;

12. 997 first = i+1;

13. 998 is_key = 1; //注意这一行，恢复原始值

14. 999 value = 0;

复制代码

循环结束以后，所有的HTTP头都读出来了。最后还要做一些后期工作，这里不详细讲了。到这里为止，这个复杂的函数就讲完了。接着上面的讲，现在设置状态为CON_STATE_HANDLE_REQUEST，要开始处理请求了。

2.2 CON_STATE_HANDLE_REQUEST，处理HTTP请求
处理HTTP请求只调用一个函数http_response_prepare，当然了，这个函数也是不短，有500行的样子，复杂度没有上面的解析函数高，但是与其它源文件的关联度却要大得多。

1. 1427 switch (r = http_response_prepare(srv, con)) {

如果http_response_prepare函数调用成功了，就把HTTP状态设置为200，即OK状态。然后把状态机的状态改为CON_STATE_RESPONSE_START，开始回应。

1. 1465 if (con->http_status == 0) con->http_status = 200;

2. 1466

3. 1467 /* we have something to send, go on */

4. 1468 connection_set_state(srv, con, CON_STATE_RESPONSE_START);

下面开始讲解http_response_prepare这个函数，这个函数位于response.c文件当中。这个函数前面有许多准备工作还有许多检查，我没有认真跟进去看过，这个函数还调了许多插件函数，我没有一一跟进去了，所以很多内容都略过了。我是从这个函数看起的。

1. 645 switch(r = plugins_call_handle_subrequest_start(srv, con)) {

plugins_call_handle_subrequest_start这个函数调用插件中的handle_subrequest_start函数指针，真正做了事情的是前面提到的mod_indexfile模块还有mod_staticfile模块，mod_indexfile模块中在mod_indexfile_plugin_init函数中将handle_subrequest_start 函数指针指向了
mod_indexfile_subrequest函数。

1. 214 p->handle_subrequest_start = mod_indexfile_subrequest;

那这个函数到底做了什么呢？它把配置文件中保存的四个首页名字取出来，一个个加到doc root后面，然后看看这个文件是否存在，如果存在就完成任务。

1. 155 /* indexfile */

2. 156 for (k = 0; k < p->conf.indexfiles->used; k++) {

3. 157 data_string *ds = (data_string *)p->conf.indexfiles->data[k]; //取出首页名

4. 158

5. 159 if (ds->value && ds->value->ptr[0] == '/') {

6. 160 /* if the index-file starts with a prefix as use this file as

7. 161 * index-generator */

8. 162 buffer_copy_string_buffer(p->tmp_buf, con->physical.doc_root);

9. 163 } else {

10. 164 buffer_copy_string_buffer(p->tmp_buf, con->physical.path);

11. 165 }

12. 166 buffer_append_string_buffer(p->tmp_buf, ds->value); //附加

13. 167

14. 168 if (HANDLER_ERROR == stat_cache_get_entry(srv, con, p->tmp_buf, &sce)) { //检

下面将这个完整的文件名保存到phsical.path当中。

1. 194 /* rewrite uri.path to the real path (/ -> /index.php) */

2. 195 buffer_append_string_buffer(con->uri.path, ds->value);

3. 196 buffer_copy_string_buffer(con->physical.path, p->tmp_buf);

5. mod_staticfile模块中的mod_staticfile_plugin_init函数中将handle_subrequest_start 指针指向mod_staticfile_subrequest函数。

6. [code]

7. 540 p->handle_subrequest_start = mod_staticfile_subrequest;

这个函数又做了什么呢？它的任务是填好回应包的HTTP头，并且把index.html添加到回应队列当中去。这个函数还涉及到cache，cache部分我一无所知，没有看过，就无能为力了。catche完以后，开始填HTTP头，包括以下几个部分："Content-Type","Accept-Ranges","ETag","Last-Modified",最后将文件附加到回应队列里去。

1. 522 /* we add it here for all requests

2. 523 * the HEAD request will drop it afterwards again

3. 524 */

4. 525 http_chunk_append_file(srv, con, con->physical.path, 0, sce->st.st_size);

在http_chunk_append_file函数中，会调用

1. 65 chunkqueue_append_file(cq, fn, offset, len);

而chunkqueue_append_file这个函数中会附加一个类型为FILE_CHUNK;的chunk结构到回应队列里。

1. 168 c = chunkqueue_get_unused_chunk(cq);

2. 169

3. 170 c->type = FILE_CHUNK; //注意这里

4. 171

5. 172 buffer_copy_string_buffer(c->file.name, fn);

6. 173 c->file.start = offset;

7. 174 c->file.length = len;

8. 175 c->offset = 0;

9. 176

10. 177 chunkqueue_append_chunk(cq, c);

这里为什么要对FILE_CHUNK特别说明一下，因为在发送数据的时候，如果是FILE_CHUNK这个类型会调一个单独的函数，这个等后面再详细讲了。

在调完 plugins_call_handle_subrequest以后，http_response_prepare函数就成功返回了。接着上面的讲，这个时候该改状态机的状态了。状态机的状态被改为CON_STATE_RESPONSE_START。

2.3、CON_STATE_RESPONSE_START

准备发送的HTTP头还有index.html文件内容，是否可以发送了呢？答案是否定的。还需要做一些其它工作才能准备好。

1. 1496 /*

2. 1497 * the decision is done

3. 1498 * - create the HTTP-Response-Header

4. 1499 *

5. 1500 */

6. 1501

7. 1502 if (srv->srvconf.log_state_handling) {

8. 1503 log_error_write(srv, __FILE__, __LINE__, "sds",

9. 1504 "state for fd", con->fd, connection_get_state(con->state));

10. 1505 }

11. 1506

12. 1507 if (-1 == connection_handle_write_prepare(srv, con)) {

13. 1508 connection_set_state(srv, con, CON_STATE_ERROR);

14. 1509

15. 1510 break;

16. 1511 }

17. 1512

18. 1513 connection_set_state(srv, con, CON_STATE_WRITE);

connection_handle_write_prepare函数主要是写一下"Content-Length"这个HTTP头，然后调用一个函数

1. 590 http_response_write_header(srv, con);

其它的工作都在http_response_write_header函数当中完成，http_response_write_header函数位于response.c当中。这个函数写的是前面一些东西，其实就是HTTP/1.1 200 OK这一行。然后再检查几个HTTP头，如果没有的话就添加一份。

1. 35 b = chunkqueue_get_prepend_buffer(con->write_queue);

2. 36

3. 37 if (con->request.http_version == HTTP_VERSION_1_1) {

4. 38 buffer_copy_string_len(b, CONST_STR_LEN("HTTP/1.1 ")); // HTTP/1.1

5. 39 } else {

6. 40 buffer_copy_string_len(b, CONST_STR_LEN("HTTP/1.0 "));

7. 41 }

8. 42 buffer_append_long(b, con->http_status); // 200

9. 43 buffer_append_string_len(b, CONST_STR_LEN(" "));

10. 44 buffer_append_string(b, get_http_status_name(con->http_status)); // OK

11.

下面开始添加前面遗漏的HTTP头，Date还有Server。

1. 86 if (!have_date) {

2. 87 /* HTTP/1.1 requires a Date: header */

3. 88 buffer_append_string_len(b, CONST_STR_LEN("\r\nDate: "));

4. 89

5. 90 /* cache the generated timestamp */

6. 91 if (srv->cur_ts != srv->last_generated_date_ts) {

7. 92 buffer_prepare_copy(srv->ts_date_str, 255);

8. 93

9. 94 strftime(srv->ts_date_str->ptr, srv->ts_date_str->size - 1,

10. 95 "%a, %d %b %Y %H:%M:%S GMT", gmtime(&(srv->cur_ts)));

11. 96

12. 97 srv->ts_date_str->used = strlen(srv->ts_date_str->ptr) + 1;

13. 98

14. 99 srv->last_generated_date_ts = srv->cur_ts;

15. 100 }

16. 101

17.

18. 105 if (!have_server) {

19. 106 if (buffer_is_empty(con->conf.server_tag)) {

20. 107 buffer_append_string_len(b, CONST_STR_LEN("\r\nServer: " PACKAGE_NAME "/" PACKAGE_VERSION));

21. 108 } else if (con->conf.server_tag->used > 1) {

22. 109 buffer_append_string_len(b, CONST_STR_LEN("\r\nServer: "));

23. 110 buffer_append_string_encoded(b, CONST_BUF_LEN(con->conf.server_tag), ENCODING_HTTP_HEADER);

24. 111 }

25. 112 }

26. 113

27. 114 buffer_append_string_len(b, CONST_STR_LEN("\r\n\r\n"));

28. 115

好了，到此为止，所有的数据都已经准备齐全了，可以发送了。终于可以把状态设成CON_STATE_WRITE了。

2.4 CON_STATE_WRITE
CON_STATE_WRITE，这个地方只有一点需要讲一下，那就是发送文件的时候lighttpd做了一个单独处理。
connection_handle_write->network_write_chunkqueue-> srv->network_backend_write，好了， srv->network_backend_write这个地方就是我要讲一下的。这又是一个绕来绕去的过程，确实比较痛苦……首先要从network.c说起……network.c中有一个函数名为network_init，这个函数是在server.c当中被main函数调用的。在network_init函数当中，有一个名为network_backends的数组

1. 474 struct nb_map {

2. 475 network_backend_t nb;

3. 476 const char *name;

4. 477 } network_backends[] = {

5. 478 /* lowest id wins */

6. 479 #if defined USE_LINUX_SENDFILE

7. 480 { NETWORK_BACKEND_LINUX_SENDFILE, "linux-sendfile" },

8. 481 #endif

9. 482 #if defined USE_FREEBSD_SENDFILE

10. 483 { NETWORK_BACKEND_FREEBSD_SENDFILE, "freebsd-sendfile" },

11. 484 #endif

12. 485 #if defined USE_SOLARIS_SENDFILEV

13. 486 { NETWORK_BACKEND_SOLARIS_SENDFILEV, "solaris-sendfilev" },

14. 487 #endif

15. 488 #if defined USE_WRITEV

16. 489 { NETWORK_BACKEND_WRITEV, "writev" },

17. 490 #endif

18. 491 { NETWORK_BACKEND_WRITE, "write" },

19. 492 { NETWORK_BACKEND_UNSET, NULL }

20. 493 };

因为我用的是debian，所以是480行那一项了。这一项位于数组0的位置。再往下看

1. 510 /* get a usefull default */

2. 511 backend = network_backends[0].nb;

backend赋值了，赋成了NETWORK_BACKEND_LINUX_SENDFILE。这还没完，还有下文，请不要着急-_-!!!
正主终于上场了……

1. 533 switch(backend) {

2. 534 case NETWORK_BACKEND_WRITE:

3. 535 srv->network_backend_write = network_write_chunkqueue_write;

4. 536 break;

5. 537 #ifdef USE_WRITEV

6. 538 case NETWORK_BACKEND_WRITEV:

7. 539 srv->network_backend_write = network_write_chunkqueue_writev;

8. 540 break;

9. 541 #endif

10. 542 #ifdef USE_LINUX_SENDFILE

11. 543 case NETWORK_BACKEND_LINUX_SENDFILE:

12. 544 srv->network_backend_write = network_write_chunkqueue_linuxsendfile; //请注意

13. 545 break;

14. 546 #endif

15. 547 #ifdef USE_FREEBSD_SENDFILE

16. 548 case NETWORK_BACKEND_FREEBSD_SENDFILE:

17. 549 srv->network_backend_write = network_write_chunkqueue_freebsdsendfile;

18. 550 break;

19. 551 #endif

20. 552 #ifdef USE_SOLARIS_SENDFILEV

21. 553 case NETWORK_BACKEND_SOLARIS_SENDFILEV:

22. 554 srv->network_backend_write = network_write_chunkqueue_solarissendfilev;

23. 555 break;

24. 556 #endif

25. 557 default:

26. 558 return -1;

27. 559 }

也就是说前面看到的那个network_backend_write函数其实就是network_write_chunkqueue_linuxsendfile; 这个函数位于linux_network_sendfile.c文件里面。在发送内容里，它会判断chunk类型，因为这里只针对index.html这个FILE_CHUNK类型，所以贴一下FILE_CHUNK部分的代码。

1. 129 case FILE_CHUNK: {

2. 130 ssize_t r;

3. 131 off_t offset;

4. 132 size_t toSend;

5. 133 stat_cache_entry *sce = NULL;

6. 134

7. 135 offset = c->file.start + c->offset;

8. 136 /* limit the toSend to 2^31-1 bytes in a chunk */

9. 137 toSend = c->file.length - c->offset > ((1 << 30) - 1) ?

10. 138 ((1 << 30) - 1) : c->file.length - c->offset;

11. 139

12. 140 /* open file if not already opened */