Nginx源代码分析之HTTP请求响应基本流程（十四）

Love The Way You Lie 2022-07-17 03:19 448阅读 0赞

HTTP的处理请求流程我们从ngx\_http\_init\_connection开始论述

里面注册了一个处理函数

rev->handler = ngx\_http\_wait\_request\_handler;

ngx\_http\_wait\_request\_handler的参数是ngx\_event\_t rev,一旦有请求到达，数据已经被复制到rev->data中，这时会调用ngx\_http\_process\_request\_line来处理请求数据

但这里存在一个keepalive的问题，如果浏览器端设置了keepalive头部，那么r->keepalive标志为真，这样ngx在调用ngx\_http\_finalize\_connection的时候，会调用ngx\_http\_set\_keepalive设置keepalive的回调ngx\_http\_keepalive\_handler，并保留当前的ngx\_connection\_t,然后直接返回。这样，在超时时间内，当同一个url请求再次到来的时候，i/o框架调用的是ngx\_http\_keepalive\_handler而不是ngx\_http\_wait\_request\_handler。

还要补充的是，在http2中，因为socket默认是keepalive状态，而且多流并发，ngx\_http\_finalize\_connection关闭的只是这个连接上的stream，因此会直接调用ngx\_http\_close\_request然后返回：

\#if (NGX\_HTTP\_V2)  
if (r->stream) \{  
ngx\_http\_close\_request(r, 0);  
return;  
\}  
\#endif

而在ngx\_http\_close\_request中，也不会关闭连接，而是关闭当前流：

\#if (NGX\_HTTP\_V2)  
if (r->stream) \{  
ngx\_http\_v2\_close\_stream(r->stream, rc);  
return;  
\}  
\#endif

ngx\_http\_process\_request\_line的主要代码如下：

rc = NGX\_AGAIN;  
for ( ;; ) \{  
if (rc == NGX\_AGAIN) \{  
n = ngx\_http\_read\_request\_header(r);  
if (n == NGX\_AGAIN || n == NGX\_ERROR) \{  
return;  
\}  
\}  
rc = ngx\_http\_parse\_request\_line(r, r->header\_in);  
if (rc == NGX\_OK) \{  
if (ngx\_http\_process\_request\_uri(r) != NGX\_OK) \{  
return;  
\}  
if (r->host\_start && r->host\_end) \{  
host.len = r->host\_end - r->host\_start;  
host.data = r->host\_start;  
rc = ngx\_http\_validate\_host(&host, r->pool, 0);  
  
if (rc == NGX\_DECLINED) \{  
ngx\_log\_error(NGX\_LOG\_INFO, c->log, 0,  
"client sent invalid host in request line");  
ngx\_http\_finalize\_request(r, NGX\_HTTP\_BAD\_REQUEST);  
return;  
\}  
if (rc == NGX\_ERROR) \{  
ngx\_http\_close\_request(r, NGX\_HTTP\_INTERNAL\_SERVER\_ERROR);  
return;  
\}  
if (ngx\_http\_set\_virtual\_server(r, &host) == NGX\_ERROR) \{  
return;  
\}  
r->headers\_in.server = host;  
\}  
if (r->http\_version < NGX\_HTTP\_VERSION\_10) \{  
if (r->headers\_in.server.len == 0  
&& ngx\_http\_set\_virtual\_server(r, &r->headers\_in.server)  
== NGX\_ERROR)  
\{  
return;  
\}  
ngx\_http\_process\_request(r);  
return;  
\}  
c->log->action = "reading client request headers";  
rev->handler = ngx\_http\_process\_request\_headers;  
ngx\_http\_process\_request\_headers(rev);  
return;  
\}  
if (r->header\_in->pos == r->header\_in->end) \{

rv = ngx\_http\_alloc\_large\_header\_buffer(r, 1);  
if (rv == NGX\_ERROR) \{  
ngx\_http\_close\_request(r, NGX\_HTTP\_INTERNAL\_SERVER\_ERROR);  
return;  
\}  
if (rv == NGX\_DECLINED) \{  
r->request\_line.len = r->header\_in->end - r->request\_start;  
r->request\_line.data = r->request\_start;  
ngx\_log\_error(NGX\_LOG\_INFO, c->log, 0,  
"client sent too long URI");  
ngx\_http\_finalize\_request(r, NGX\_HTTP\_REQUEST\_URI\_TOO\_LARGE);  
return;  
\}  
\}  
\}

该函数的主要处理逻辑是按行读取r->connection->read中的数据，每成功读取到一行头部数据，再调用ngx\_http\_parse\_request\_line，根据http协议解析成http的头部,该函数的返回值如果是NGX\_AGAIN，说明头部数据不完整，需要继续解析，说过返回NGX\_OK,说明已经得到一个完整的头部，进入下一个处理流程。

首先调用ngx\_http\_process\_request\_uri处理url,接着调用ngx\_http\_set\_virtual\_server，该函数会根据已得到的host头部，在服务器初始化过程中配置的http\{\}中匹配一个server，其中关键代码如下：

rc = ngx\_http\_find\_virtual\_server(r->connection,  
hc->addr\_conf->virtual\_names,  
host, r, &cscf);  
  
  
if (rc == NGX\_ERROR) \{  
ngx\_http\_close\_request(r, NGX\_HTTP\_INTERNAL\_SERVER\_ERROR);  
return NGX\_ERROR;  
\}  
  
  
if (rc == NGX\_DECLINED) \{  
return NGX\_OK;  
\}  
  
  
r->srv\_conf = cscf->ctx->srv\_conf;  
r->loc\_conf = cscf->ctx->loc\_conf;

重点是ngx\_http\_find\_virtual\_server，检索当前配置的server表，找到对应的server。最后2行，把匹配的svr\_conf,以及server里面的location表赋给ngx\_http\_request\_t \*r,这样，后面的执行流程就能通过ngx\_http\_request\_t \*r 调用相应模块的handler来执行正确的处理。

然后涉及到一个HTTP版本的问题，如果低于1.0.直接调用ngx\_http\_process\_request,对于高于1.0请求，则调用ngx\_http\_process\_request\_headers,该函数的过程主要是循环调用ngx\_http\_parse\_header\_line来处理请求的所有头部，当ngx\_http\_parse\_header\_line返回NGX\_HTTP\_PARSE\_HEADER\_DONE的时候，再调用ngx\_http\_process\_request。

ngx\_http\_process\_request的主要功能则是调用ngx\_http\_handler，ngx\_http\_handler判断当前http请求是否是内部跳转，然后设置r->phase\_handler。最后调用

ngx\_http\_core\_run\_phases，这个函数的功能是循环检查已经注册的处理阶段，并调用每个阶段的checker来执行本阶段需要完成的任务。

这里要回头解释一下nginx的阶段的的具体含义和原理，在ngx\_http\_core\_module.h中定义了所有的阶段

typedef enum \{  
NGX\_HTTP\_POST\_READ\_PHASE = 0,  
NGX\_HTTP\_SERVER\_REWRITE\_PHASE,  
NGX\_HTTP\_FIND\_CONFIG\_PHASE,  
NGX\_HTTP\_REWRITE\_PHASE,  
NGX\_HTTP\_POST\_REWRITE\_PHASE,  
NGX\_HTTP\_PREACCESS\_PHASE,  
NGX\_HTTP\_ACCESS\_PHASE,  
NGX\_HTTP\_POST\_ACCESS\_PHASE,  
NGX\_HTTP\_TRY\_FILES\_PHASE,  
NGX\_HTTP\_CONTENT\_PHASE,  
NGX\_HTTP\_LOG\_PHASE  
\} ngx\_http\_phases;

nginx把整个请求响应划分为11个阶段，主要包括地址重定向，权限检查，请求文件，内容处理，日志记录等几个大的阶段，每个大的阶段分类下面可能有几个细阶段，比如重定向又分成NGX\_HTTP\_SERVER\_REWRITE\_PHASE，NGX\_HTTP\_FIND\_CONFIG\_PHASE，NGX\_HTTP\_REWRITE\_PHASE，NGX\_HTTP\_POST\_REWRITE\_PHASE这几个阶段。我们知道，nginx有一个基本的核心模块ngx\_http\_core\_module,还有其他许多功能模块，比如ngx\_http\_proxy\_module,ngx\_http\_mp4\_module等，以及第三方的可选模块。每个模块可以吧自己的处理函数注册到以上的阶段中。

阶段的初始化是在ngx\_http.c的ngx\_http\_init\_phases里面实现的，函数会初始化ngx\_http\_core\_main\_conf\_t下面的ngx\_http\_phase\_t的handlers数组：

if (ngx\_array\_init(&cmcf->phases\[NGX\_HTTP\_CONTENT\_PHASE\].handlers,  
cf->pool, 4, sizeof(ngx\_http\_handler\_pt))  
!= NGX\_OK)  
\{  
return NGX\_ERROR;  
\}

接着，循环检查已注册的所有模块，调用模块的postconfiguration方法，该方法会把本模块的handler指针写到handlers数组里面。比如static module的postconfiguration是这样的

static ngx\_int\_t  
ngx\_http\_static\_init(ngx\_conf\_t \*cf)  
\{  
ngx\_http\_handler\_pt \*h;  
ngx\_http\_core\_main\_conf\_t \*cmcf;  
  
  
cmcf = ngx\_http\_conf\_get\_module\_main\_conf(cf, ngx\_http\_core\_module);  
  
  
h = ngx\_array\_push(&cmcf->phases\[NGX\_HTTP\_CONTENT\_PHASE\].handlers);  
if (h == NULL) \{  
return NGX\_ERROR;  
\}  
  
  
\*h = ngx\_http\_static\_handler;  
  
  
return NGX\_OK;  
\}

这些都准备好之后，会调用ngx\_http\_init\_phase\_handlers，他的作用是把已经注册的各阶段的处理函数和模块的处理函数写入到ngx\_http\_core\_main\_conf\_t里面的phase\_engine.handlers数据结构中，这样ngx\_http\_core\_run\_phases函数可以循环检查cmcf->phase\_engine.handlers。然后判断是否执行这些阶段的处理函数：

cmcf = ngx\_http\_get\_module\_main\_conf(r, ngx\_http\_core\_module);  
  
  
ph = cmcf->phase\_engine.handlers;  
  
  
while (ph\[r->phase\_handler\].checker) \{  
  
  
rc = ph\[r->phase\_handler\].checker(r, &ph\[r->phase\_handler\]);  
  
  
if (rc == NGX\_OK) \{  
return;  
\}  
\}

在前面的我们已经介绍过r->phase\_handler是一个编号，其值一般是0，这样调用会从第一个注册的阶段的checker开始执行，每个checker内部会调用ph->handler，然后根据返回值决定r->phase\_handler的值是递增还是直接指向ph-next。这样当前的checker调用结束后，会继续调用本阶段的handler或者下一个阶段的handler。一切都由phase\_handler这个编号来的值来决定

当执行到NGX\_HTTP\_CONTENT\_PHASE后，这个阶段的模块的函数一般会开始向客户端返回结果，这样HTTP流程就来到了响应阶段,如果是一个静态模块，响应比较简单，主要是根据请求的uri来读取本地文件或者缓存文件，然后填充响应包的头部和数据段，然后调用ngx\_http\_output\_filter把数据发送出去。细节可以查看ngx\_http\_static\_handler函数的代码。