//接收到http请求行与请求头后，http的处理流程,是第一个http处理请求的读事件回调

//这个函数执行后，将把读写事件的回调设置为ngx_http_request_handler。这样下次再有事件时

//将调用ngx_http_request_handler函数来处理，而不会再调用ngx_http_process_request了

staticvoidngx_http_process_request(ngx_http_request_t*r)

//因为已经接收完http请求行、请求头部了，准备调用各个http模块处理请求了。

//因此需要接收任何来自客户端的读事件，也就不存在接收http请求头部超时问题

if(c->read->timer_set)

ngx_del_timer(c->read);

//重新设置当前连接的读写事件回调

c->read->handler=ngx_http_request_handler;

c->write->handler=ngx_http_request_handler;

//设置http请求对象的读事件回调，这个回调不做任何的事情。

//那http请求对象的读事件回调，与上面的连接对应的读事件回调有什么关系呢?

//当读事件发生后，连接对应的读事件回调ngx_http_request_handler会被调用，

//在这个回调内会调用http请求对象的读事件回调ngx_http_block_reading，而这个回调是

//不会做任何事件的，因此相当于忽略了读事件。因为已经接收完了请求行请求头，现在要做的是调用各个http模块，

//对接收到的请求行请求头进行处理

r->read_event_handler=ngx_http_block_reading;

//调用各个http模块协同处理这个请求

ngx_http_run_posted_requests(c);

}

//http请求处理读与写事件的回调，在ngx_http_process_request函数中设置。

//这个函数中将会调用http请求对象的读写事件回调。将event事件模块与http框架关联起来

staticvoidngx_http_request_handler(ngx_event_t*ev)

//如果同时发生读写事件，则只有写事件才会触发。写事件优先级更高

r->write_event_handler(r);//在函数ngx_http_handler设置为:ngx_http_core_run_phases

r->read_event_handler(r);//在函数ngx_http_process_request设置为:ngx_http_block_reading

ngx_http_run_posted_requests(c);

}

//调用各个http模块协同处理这个请求

voidngx_http_handler(ngx_http_request_t*r)

//不需要进行内部跳转。什么是内部跳转?例如有个location结构，里面的

//将数组序号设为0,表示从数组第一个元素开始处理http请求

//这个下标很重要，决定了当前要处理的是11个阶段中的哪一个阶段，

//以及由这个阶段的哪个http模块处理请求

cmcf=ngx_http_get_module_main_conf(r,ngx_http_core_module);

//将序号设置为server_rewrite_index

r->phase_handler=cmcf->phase_engine.server_rewrite_index;

//设置请求对象的写事件回调，这个回调将会调度介入11个http阶段的各个http模块

r->write_event_handler=ngx_http_core_run_phases;

//开始调度介入11个http阶段的各个http模块

ngx_http_core_run_phases(r);

}

//调用各个http模块协同处理这个请求,checker函数内部会修改phase_handler

voidngx_http_core_run_phases(ngx_http_request_t*r)

cmcf=ngx_http_get_module_main_conf(r,ngx_http_core_module);

ph=cmcf->phase_engine.handlers;

//调用各个http模块的checker方法，使得各个http模块可以介入http请求

while(ph[r->phase_handler].checker)

rc=ph[r->phase_handler].checker(r,&ph[r->phase_handler]);

//从http模块返回ngx_ok，http框架则会把控制全交还给事件模块

}

//开始解析http块

staticchar*ngx_http_block(ngx_conf_t*cf,ngx_command_t*cmd,void*conf)

//http配置解析完成后的后续处理,使得各个http模块可以介入到11个http阶段

for(m=0;ngx_modules[m];m++)

if(ngx_modules[m]->type!=ngx_http_module)

module=ngx_modules[m]->ctx;

if(module->postconfiguration)

//每一个http模块的在这个postconfiguration函数中，都可以把自己注册到11个http阶段

if(module->postconfiguration(cf)!=ngx_ok)

}

//静态模块将自己注册到11个http请求阶段中的ngx_http_content_phase阶段

staticngx_int_tngx_http_static_init(ngx_conf_t*cf)

h=ngx_array_push(&cmcf->phases[ngx_http_content_phase].handlers);

//静态模块在ngx_http_content_phase阶段的处理方法

*h=ngx_http_static_handler;

}

//访问权限模块将自己注册到11个http请求阶段中的ngx_http_access_phase阶段

staticngx_int_tngx_http_access_init(ngx_conf_t*cf)

cmcf=ngx_http_conf_get_module_main_conf(cf,ngx_http_core_module);

h=ngx_array_push(&cmcf->phases[ngx_http_access_phase].handlers);

//访问权限模块在ngx_http_access_phase阶段的处理方法

*h=ngx_http_access_handler;

}

//开始解析http块

staticchar*ngx_http_block(ngx_conf_t*cf,ngx_command_t*cmd,void*conf)

if(ngx_http_init_phase_handlers(cf,cmcf)!=ngx_ok)

staticngx_int_tngx_http_init_phase_handlers(ngx_conf_t*cf,ngx_http_core_main_conf_t*cmcf)

//11个http请求阶段，每一个阶段都可以有多个http模块介入。

//这里统计11个节点一共有多个少http模块。以便下面开辟空间

for(i=0;i<ngx_http_log_phase;i++)

n+=cmcf->phases[i].handlers.nelts;

//开辟空间，存放介入11个处理阶段的所有http模块的回调

ph=ngx_pcalloc(cf->pool,n*sizeof(ngx_http_phase_handler_t)+sizeof(void*));

cmcf->phase_engine.handlers=ph;

//对于每一个http处理阶段，给该阶段中所有介入的http模块赋值

for(i=0;i<ngx_http_log_phase;i++)

h=cmcf->phases[i].handlers.elts;

casengx_http_server_rewrite_phase://根据请求的uri查找location之前，修改请求的uri阶段

if(cmcf->phase_engine.server_rewrite_index==(ngx_uint_t)-1)

cmcf->phase_engine.server_rewrite_index=n;//重定向模块在数组中的位置

checker=ngx_http_core_rewrite_phase;//每一个阶段的checker回调

casengx_http_find_config_phase://根据请求的uri查找location阶段(只能由http框架实现)

ph->checker=ngx_http_core_find_config_phase;

casengx_http_rewrite_phase://根据请求的rui查找location之后，修改请求的uri阶段

if(cmcf->phase_engine.location_rewrite_index==(ngx_uint_t)-1)

cmcf->phase_engine.location_rewrite_index=n;

checker=ngx_http_core_rewrite_phase;

casengx_http_post_rewrite_phase://ngx_http_rewrite_phase阶段修改rul后，防止递归修改uri导致死循环阶段

ph->checker=ngx_http_core_post_rewrite_phase;

ph->next=find_config_index;//目的是为了地址重写后，跳转到ngx_http_find_config_phase阶段，根据

casengx_http_access_phase://是否允许访问服务器阶段

checker=ngx_http_core_access_phase;

casengx_http_post_access_phase://根据ngx_http_access_phase阶段的错误码，给客户端构造响应阶段

ph->checker=ngx_http_core_post_access_phase;

casengx_http_try_files_phase://try_file阶段

ph->checker=ngx_http_core_try_files_phase;

casengx_http_content_phase://处理http请求内容阶段，大部分http模块最愿意介入的阶段

checker=ngx_http_core_content_phase;

//ngx_http_post_read_phase,

//ngx_http_preaccess_phase,

//ngx_http_log_phase三个阶段的checker方法

checker=ngx_http_core_generic_phase;

n+=cmcf->phases[i].handlers.nelts;

//每一个阶段中所介入的所有http模块，同一个阶段中的所有http模块有唯一的checker回调，

//但handler回调每一个模块自己实现

for(j=cmcf->phases[i].handlers.nelts-1;j>=0;j--)

}

//ngx_http_post_read_phase,

//ngx_http_preaccess_phase,

//ngx_http_log_phase三个阶段的checker方法

//返回值:ngx_ok，http框架会将控制权交还给epoll模块

ngx_int_tngx_http_core_generic_phase(ngx_http_request_t*r,ngx_http_phase_handler_t*ph)

//调用http模块的处理方法，这样这个http模块就介入到了这个请求阶段

//跳转到下一个http阶段执行

r->phase_handler=ph->next;

//执行本阶段的下一个http模块

//表示刚执行的handler无法在这一次调度中处理完这一个阶段，

if(rc==ngx_again||rc==ngx_done)

ngx_http_finalize_request(r,rc);