Nginx 中 HTTP模块初始化
在前面的文章《 Nginx 配置解析》简单讲解了通用模块的配置项解析,并且大概讲解了HTTP 模块的配置项解析过程,本文更具体的分析 HTTP 模块的初始化过程。HTTP 模块初始化过程主要有:上下文结构初始化、配置项解析、配置项合并、server 相关端口设置。
HTTP 模块接口
ngx_http_module_t 结构体
在 Nginx 中,结构体 ngx_module_t 是 Nginx 模块最基本的接口。对于每一种不同类型的模块,都有一个具体的结构体来描述这一类模块的通用接口。在Nginx 中定义了 HTTP 模块的通用接口 ngx_http_module_t 结构体,该结构体定义在文件src/http/ngx_http_config.h:我们把直属于http{}、server{}、location{} 块的配置项分别称为main、srv、loc 级别配置项。
/* 所有HTTP模块的通用接口结构ngx_http_module_t */ typedef struct { /* 在解析http{}块内的配置项前回调 */ ngx_int_t (*preconfiguration)(ngx_conf_t *cf); /* 在解析http{}块内的配置项后回调 */ ngx_int_t (*postconfiguration)(ngx_conf_t *cf); /* * 创建用于存储HTTP全局配置项的结构体; * 该结构体中的成员将保存直属于http{}块的配置项参数; * 该方法在解析main配置项前调用; */ void *(*create_main_conf)(ngx_conf_t *cf); /* 解析完main配置项后回调 */ char *(*init_main_conf)(ngx_conf_t *cf, void *conf); /* * 创建用于存储可同时出现在main、srv级别配置项的结构体; * 该结构体中的成员与server配置是相关联的; */ void *(*create_srv_conf)(ngx_conf_t *cf); /* * 由create_srv_conf产生的结构体所要解析的配置项, * 可能同时出现在main、srv级别中, * merge_srv_conf 方法可以将出现在main级别中的配置项值合并到srv级别的配置项中; */ char *(*merge_srv_conf)(ngx_conf_t *cf, void *prev, void *conf); /* * 创建用于存储同时出现在main、srv、loc级别配置项的结构体, * 该结构体成员与location配置相关联; */ void *(*create_loc_conf)(ngx_conf_t *cf); /* * 由create_loc_conf 产生的结构体所要解析的配置项, * 可能同时出现在main、srv、loc级别的配置项中, * merge_loc_conf 方法将出现在main、srv级别的配置项值合并到loc级别的配置项中; */ char *(*merge_loc_conf)(ngx_conf_t *cf, void *prev, void *conf); } ngx_http_module_t;
ngx_http_conf_ctx_t 结构体
在 HTTP 模块中,管理 HTTP 模块配置项的结构由 ngx_http_conf_ctx_t 实现,该结构有三个成员,分别指向三个指针数组,指针数组是由相应地 HTTP 模块create_main_conf、create_srv_conf、create_loc_conf 方法创建的结构体指针组成的数组。ngx_http_conf_ctx_t 结构体定义在文件 src/http/ngx_http_config.h 中:
/* HTTP框架的上下文结构体ngx_http_conf_ctx_t */ typedef struct { /* * 指向一个指针数组; * 数组中的每个成员都是由所有HTTP模块create_main_conf方法创建的存放全局配置项的结构体, * 它们存放着解析直属于http{}块内main级别的配置项参数; */ void **main_conf; /* * 指向一个指针数组; * 数组中的每个成员都是由所有HTTP模块create_srv_conf方法创建的与server相关的配置项结构体, * 它们存放着main级别,或srv级别的配置项参数; * 这与当前的ngx_http_conf_ctx_t是在解析http{}或server{}块时创建有关; */ void **srv_conf; /* * 指向一个指针数组; * 数组中的每个成员都是由所有HTTP模块create_loc_conf方法创建的与location有关的配置项结构体, * 它们存放着main级别、srv级别、loc级别的配置项参数; * 这样当前ngx_http_conf_ctx_t是在解析http{}、server{}或location{}块时创建有关; */ void **loc_conf; } ngx_http_conf_ctx_t;
ngx_http_module 核心模块
ngx_http_module 核心模块定义
ngx_http_module 是 HTTP 模块的核心模块,该模块的功能是:定义新的 HTTP 模块类型,并为每个HTTP 模块定义通用接口 ngx_http_module_t 结构体,管理 HTTP 模块生成的配置项结构体,并解析HTTP 类配置项。该模块定义在文件 src/http/ngx_http.c 中:
/* 定义http核心模块 */ ngx_module_t ngx_http_module = { NGX_MODULE_V1, &ngx_http_module_ctx, /* module context */ ngx_http_commands, /* module directives */ NGX_CORE_MODULE, /* module type */ NULL, /* init master */ NULL, /* init module */ NULL, /* init process */ NULL, /* init thread */ NULL, /* exit thread */ NULL, /* exit process */ NULL, /* exit master */ NGX_MODULE_V1_PADDING };
ngx_http_module 作为核心模块,必须定义核心模块的通用接口上下文结构,其通用接口上下文结构定义在文件src/http/ngx_http.c 中:在 ngx_http_module 核心模块中只定义了 http 模块的名称。
/* 定义核心模块的通用接口上下文结构 */ static ngx_core_module_t ngx_http_module_ctx = { ngx_string("http"), NULL, NULL };
在 ngx_http_module 模块中定义了 http{} 块感兴趣的配置项数组,配置项数组定义在文件 src/http/ngx_http.c 中:
/* 定义http模块感兴趣的配置项,即配置项指令数组 */ static ngx_command_t ngx_http_commands[] = { { ngx_string("http"), NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS, ngx_http_block, 0, 0, NULL }, ngx_null_command };
从 ngx_http_module 模块的定义中可以知道,该模块只有一个初始化处理方法ngx_http_block,该处理方法是 HTTP 模块的初始化作用。
ngx_http_module 核心模块初始化
在上面 ngx_http_module 模块的定义中已经知道,HTTP 模块的初始化过程由函数ngx_http_block 实现,首先先给出该函数的整体分析,接着对该函数进行具体的分析。该函数定义在文件src/http/ngx_http.c 中:
/* HTTP框架初始化 */ static char * ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) { char *rv; ngx_uint_t mi, m, s; ngx_conf_t pcf; ngx_http_module_t *module; ngx_http_conf_ctx_t *ctx; ngx_http_core_loc_conf_t *clcf; ngx_http_core_srv_conf_t **cscfp; ngx_http_core_main_conf_t *cmcf; /* the main http context */ /* 分配HTTP框架的上下文结构ngx_http_conf_ctx_t 空间 */ ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)); if (ctx == NULL) { return NGX_CONF_ERROR; } /* * conf 是结构体ngx_cycle_t 成员conf_ctx数组中的元素, * 该元素conf指向ngx_http_module模块所对应的配置项结构信息; */ *(ngx_http_conf_ctx_t **) conf = ctx; /* count the number of the http modules and set up their indices */ /* 初始化所有HTTP模块的ctx_index序号 */ ngx_http_max_module = 0; for (m = 0; ngx_modules[m]; m++) { if (ngx_modules[m]->type != NGX_HTTP_MODULE) { continue; } ngx_modules[m]->ctx_index = ngx_http_max_module++; } /* * 分配存储HTTP模块main级别下的main_conf配置项的空间; */ /* the http main_conf context, it is the same in the all http contexts */ ctx->main_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module); if (ctx->main_conf == NULL) { return NGX_CONF_ERROR; } /* * 分配存储HTTP模块main级别下的srv_conf配置项的空间; */ /* * the http null srv_conf context, it is used to merge * the server{}s' srv_conf's */ ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module); if (ctx->srv_conf == NULL) { return NGX_CONF_ERROR; } /* * 分配存储HTTP模块main级别下的loc_conf配置项的空间; */ /* * the http null loc_conf context, it is used to merge * the server{}s' loc_conf's */ ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module); if (ctx->loc_conf == NULL) { return NGX_CONF_ERROR; } /* * create the main_conf's, the null srv_conf's, and the null loc_conf's * of the all http modules */ /* * 遍历所有HTTP模块,为每个HTTP模块创建main级别的配置项结构main_conf、srv_conf、loc_conf; */ for (m = 0; ngx_modules[m]; m++) { if (ngx_modules[m]->type != NGX_HTTP_MODULE) { continue; } module = ngx_modules[m]->ctx; mi = ngx_modules[m]->ctx_index; /* * 调用create_main_conf创建main级别的配置项结构main_conf; */ if (module->create_main_conf) { ctx->main_conf[mi] = module->create_main_conf(cf); if (ctx->main_conf[mi] == NULL) { return NGX_CONF_ERROR; } } /* * 调用create_srv_conf创建main级别的配置项结构srv_conf; */ if (module->create_srv_conf) { ctx->srv_conf[mi] = module->create_srv_conf(cf); if (ctx->srv_conf[mi] == NULL) { return NGX_CONF_ERROR; } } /* * 调用create_loc_conf创建main级别的配置项结构loc_conf; */ if (module->create_loc_conf) { ctx->loc_conf[mi] = module->create_loc_conf(cf); if (ctx->loc_conf[mi] == NULL) { return NGX_CONF_ERROR; } } } /* * 保存待解析配置项结构cf的副本为pcf,待解析完毕后恢复cf; * 这里备份是由于配置指令解析函数ngx_conf_parse递归调用,因此为了不影响外层的调用环境; */ pcf = *cf; /* * 把HTTP模块解析指令的上下文参数保存到配置项结构ngx_http_conf_ctx_t ctx中; */ cf->ctx = ctx;/* 值-结果 模式 */ /* 遍历所有HTTP模块,并调用每个模块的preconfiguration回调函数 */ for (m = 0; ngx_modules[m]; m++) { if (ngx_modules[m]->type != NGX_HTTP_MODULE) { continue; } module = ngx_modules[m]->ctx; if (module->preconfiguration) { if (module->preconfiguration(cf) != NGX_OK) { return NGX_CONF_ERROR; } } } /* * 调用模块通用配置项解析函数ngx_conf_parse解析http{}块内的指令; */ /* parse inside the http{} block */ cf->module_type = NGX_HTTP_MODULE;/* 模块类型为HTTP模块 */ cf->cmd_type = NGX_HTTP_MAIN_CONF;/* 指令类型为HTTP模块的main级别指令 */ /* * 开始解析http{}块内的指令; * 这里必须注意的是:http{}块内可能会包含server{}块, * 而server{}可能会包含location{}块,location{}块会嵌套location{}块; * 还需注意的是http{}块内可能有多个server{}块, * location{}块也可能有多个location{}块; * 因此,配置项解析函数ngx_conf_parse是被递归调用的;*/ rv = ngx_conf_parse(cf, NULL); if (rv != NGX_CONF_OK) { goto failed; } /* * 解析完成http{}块内的所有指令后(包括server{}、location{}块的解析), * 进行下面的程序 */ /* * init http{} main_conf's, merge the server{}s' srv_conf's * and its location{}s' loc_conf's */ /* 获取ngx_http_core_module模块的main_conf配置项结构 */ cmcf = ctx->main_conf[ngx_http_core_module.ctx_index]; /* 获取所有srv_conf配置项结构 */ cscfp = cmcf->servers.elts; /* * 遍历所有HTTP模块,并初始化每个HTTP模块的main_conf结构, * 同时合并srv_conf 结构(当然srv_conf结构里面包含loc_conf结构,所有也合并loc_conf结构); */ for (m = 0; ngx_modules[m]; m++) { if (ngx_modules[m]->type != NGX_HTTP_MODULE) { continue; } /* * ngx_modules[m]是一个ngx_module_t模块结构体, * 它的ctx成员相对于HTTP模块来说是ngx_http_module_t接口; */ module = ngx_modules[m]->ctx; /* 获取当前HTTP模块在HTTP模块类的序号 */ mi = ngx_modules[m]->ctx_index; /* 初始化HTTP模块的main_conf结构 */ /* init http{} main_conf's */ if (module->init_main_conf) { rv = module->init_main_conf(cf, ctx->main_conf[mi]); if (rv != NGX_CONF_OK) { goto failed; } } /* 合并当前HTTP模块不同级别的配置项结构 */ rv = ngx_http_merge_servers(cf, cmcf, module, mi); if (rv != NGX_CONF_OK) { goto failed; } } /* 以下是监听端口管理的内容 */ /* 静态二叉查找树来保存location配置 */ /* create location trees */ /* 遍历http{}块下的所有server{}块 */ for (s = 0; s servers.nelts; s++) { /* 获取server{}块下location{}块所对应的ngx_http_core_loc_conf_t loc_conf结构体 */ clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index]; /* * 将ngx_http_core_loc_conf_t 组成的双向链表按照location匹配字符串进行排序; * 注意:location{}块可能嵌套location{}块,所以该函数是递归调用; */ if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) { return NGX_CONF_ERROR; } /* * 按照已排序的location{}的双向链表构建静态的二叉查找树, * 该方法也是递归调用; */ if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) { return NGX_CONF_ERROR; } } /* 初始化可添加自定义处理方法的7个HTTP阶段的动态数组 */ if (ngx_http_init_phases(cf, cmcf) != NGX_OK) { return NGX_CONF_ERROR; } /* 将HTTP请求的头部header初始化成hash结构 */ if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) { return NGX_CONF_ERROR; } /* 调用所有HTTP模块的postconfiguration方法 */ for (m = 0; ngx_modules[m]; m++) { if (ngx_modules[m]->type != NGX_HTTP_MODULE) { continue; } module = ngx_modules[m]->ctx; if (module->postconfiguration) { if (module->postconfiguration(cf) != NGX_OK) { return NGX_CONF_ERROR; } } } if (ngx_http_variables_init_vars(cf) != NGX_OK) { return NGX_CONF_ERROR; } /* * http{}'s cf->ctx was needed while the configuration merging * and in postconfiguration process */ *cf = pcf; /* 初始化phase_engine_handlers数组 */ if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) { return NGX_CONF_ERROR; } /* optimize the lists of ports, addresses and server names */ /* 设置server与监听端口的关系,并设置新连接事件的处理方法 */ if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) { return NGX_CONF_ERROR; } return NGX_CONF_OK; failed: *cf = pcf; return rv; }
从上面的分析中可以总结出 HTTP 模块初始化的流程如下:
- Nginx 进程进入主循环,在主循环中调用配置解析器解析配置文件nginx.conf;
- 在配置文件中遇到 http{} 块配置,则 HTTP 框架开始初始化并启动,其由函数 ngx_http_block() 实现;
- HTTP 框架初始化所有 HTTP 模块的序列号,并创建 3 个类型为 ngx_http_conf_ctx_t 结构的数组用于存储所有HTTP 模块的create_main_conf、create_srv_conf、create_loc_conf方法返回的指针地址;
- 调用每个 HTTP 模块的 preconfiguration 方法;
- HTTP 框架调用函数 ngx_conf_parse() 开始循环解析配置文件 nginx.conf 中的http{}块里面的所有配置项,http{} 块内可嵌套多个server{} 块,而 server{} 块可嵌套多个 location{},location{} 依旧可以嵌套location{},因此配置项解析函数是递归调用;
- HTTP 框架处理完毕 http{} 配置项,根据解析配置项的结果,必要时调用ngx_http_merge_servers 方法进行配置项合并处理,即合并main、srv、loc 级别下server、location 相关的配置项;
- 初始化可添加处理方法的 HTTP 阶段的动态数组;
- 调用所有 HTTP 模块的 postconfiguration 方法使 HTTP 模块可以处理HTTP 阶段,即将 HTTP 模块的 ngx_http_handler_pt 处理方法添加到HTTP 阶段中;
- 根据 HTTP 模块处理 HTTP 阶段的方法构造 phase_engine_handlers 数组;
- 构造 server 相关的监听端口,并设置新连接事件的回调方法为ngx_http_init_connection ;
- 继续处理其他 http{} 块之外的配置项,直到配置文件解析器处理完所有配置项后通知Nginx 主循环配置项解析完毕。此时,Nginx 才会启动Web 服务器;
ngx_http_core_module 模块
ngx_http_core_main_conf_t 结构体
在初始化 HTTP 模块的过程中,会调用配置项解析函数 ngx_conf_parse 解析 http{} 块内的配置项,当遇到server{} 块、 location{} 块配置项时,此时会调用配置项解析函数解析 server{} 和 location{} 块,在解析这两个配置块的过程中依旧会创建属于该块的配置项结构srv_conf、loc_conf,因此就会导致与http{} 块所创建的配置项结构体重复,这时候就需要对这些配置项进行管理与合并。首先先看下结构体ngx_http_core_main_conf_t,ngx_http_core_main_conf_t 是ngx_http_core_module 的 main_conf,存储了 http{} 层的配置参数。该结构体定义在文件src/http/ngx_http_core_module.h中:
/* ngx_http_core_main_conf_t 结构体 */ typedef struct { /* 指针数组,每个指针指向表示server{}块的ngx_http_core_srv_conf_t结构体地址 */ ngx_array_t servers; /* ngx_http_core_srv_conf_t */ /* 各HTTP阶段处理方法构成的phases数组构建的阶段索引 */ ngx_http_phase_engine_t phase_engine; ngx_hash_t headers_in_hash; ngx_hash_t variables_hash; ngx_array_t variables; /* ngx_http_variable_t */ ngx_uint_t ncaptures; /* 配置项中散列桶bucket最大数量 */ ngx_uint_t server_names_hash_max_size; /* 配置项中每个散列桶bucket占用内存的最大值 */ ngx_uint_t server_names_hash_bucket_size; ngx_uint_t variables_hash_max_size; ngx_uint_t variables_hash_bucket_size; ngx_hash_keys_arrays_t *variables_keys; /* 存放http{}配置块下监听的所有ngx_http_conf_port_t 端口*/ ngx_array_t *ports; ngx_uint_t try_files; /* unsigned try_files:1 */ /* * 在HTTP模块初始化时,使各HTTP模块在HTTP阶段添加处理方法, * 数组中每一个成员ngx_http_phase_t结构对应一个HTTP阶段; */ ngx_http_phase_t phases[NGX_HTTP_LOG_PHASE + 1]; } ngx_http_core_main_conf_t;
ngx_http_core_srv_conf_t 结构体
结构体 ngx_http_core_srv_conf_t,ngx_http_core_srv_conf_t 是ngx_http_core_module 的 srv_conf,存储了 server{} 层的配置参数。该结构体定义在文件src/http/ngx_http_core_module.h中:
/* ngx_http_core_srv_conf_t结构体 */ typedef struct { /* array of the ngx_http_server_name_t, "server_name" directive */ ngx_array_t server_names; /* server ctx */ /* 指向当前server{}块所属的ngx_http_conf_ctx_t结构体 */ ngx_http_conf_ctx_t *ctx; /* 当前server{}块的虚拟主机名 */ ngx_str_t server_name; size_t connection_pool_size; size_t request_pool_size; size_t client_header_buffer_size; ngx_bufs_t large_client_header_buffers; ngx_msec_t client_header_timeout; ngx_flag_t ignore_invalid_headers; ngx_flag_t merge_slashes; ngx_flag_t underscores_in_headers; unsigned listen:1; #if (NGX_PCRE) unsigned captures:1; #endif ngx_http_core_loc_conf_t **named_locations; } ngx_http_core_srv_conf_t;
ngx_http_core_loc_conf_t 结构体
结构体 ngx_http_core_loc_conf_t,ngx_http_core_loc_conf_t 是ngx_http_core_module 的 loc_conf,存储了 location{} 层的配置参数。该结构体定义在文件src/http/ngx_http_core_module.h中:
struct ngx_http_core_loc_conf_s { /* location名称,即nginx.conf配置文件中location后面的表达式 */ ngx_str_t name; /* location name */ #if (NGX_PCRE) ngx_http_regex_t *regex; #endif unsigned noname:1; /* "if () {}" block or limit_except */ unsigned lmt_excpt:1; unsigned named:1; unsigned exact_match:1; unsigned noregex:1; unsigned auto_redirect:1; #if (NGX_HTTP_GZIP) unsigned gzip_disable_msie6:2; #if (NGX_HTTP_DEGRADATION) unsigned gzip_disable_degradation:2; #endif #endif ngx_http_location_tree_node_t *static_locations; #if (NGX_PCRE) ngx_http_core_loc_conf_t **regex_locations; #endif /* 指向所属location{}块内ngx_http_conf_ctx_t 结构体中的loc_conf指针数组 */ /* pointer to the modules' loc_conf */ void **loc_conf; uint32_t limit_except; void **limit_except_loc_conf; ngx_http_handler_pt handler; /* location name length for inclusive location with inherited alias */ size_t alias; ngx_str_t root; /* root, alias */ ngx_str_t post_action; ngx_array_t *root_lengths; ngx_array_t *root_values; ngx_array_t *types; ngx_hash_t types_hash; ngx_str_t default_type; off_t client_max_body_size; /* client_max_body_size */ off_t directio; /* directio */ off_t directio_alignment; /* directio_alignment */ size_t client_body_buffer_size; /* client_body_buffer_size */ size_t send_lowat; /* send_lowat */ size_t postpone_output; /* postpone_output */ size_t limit_rate; /* limit_rate */ size_t limit_rate_after; /* limit_rate_after */ size_t sendfile_max_chunk; /* sendfile_max_chunk */ size_t read_ahead; /* read_ahead */ ngx_msec_t client_body_timeout; /* client_body_timeout */ ngx_msec_t send_timeout; /* send_timeout */ ngx_msec_t keepalive_timeout; /* keepalive_timeout */ ngx_msec_t lingering_time; /* lingering_time */ ngx_msec_t lingering_timeout; /* lingering_timeout */ ngx_msec_t resolver_timeout; /* resolver_timeout */ ngx_resolver_t *resolver; /* resolver */ time_t keepalive_header; /* keepalive_timeout */ ngx_uint_t keepalive_requests; /* keepalive_requests */ ngx_uint_t keepalive_disable; /* keepalive_disable */ ngx_uint_t satisfy; /* satisfy */ ngx_uint_t lingering_close; /* lingering_close */ ngx_uint_t if_modified_since; /* if_modified_since */ ngx_uint_t max_ranges; /* max_ranges */ ngx_uint_t client_body_in_file_only; /* client_body_in_file_only */ ngx_flag_t client_body_in_single_buffer; /* client_body_in_singe_buffer */ ngx_flag_t internal; /* internal */ ngx_flag_t sendfile; /* sendfile */ #if (NGX_HAVE_FILE_AIO) ngx_flag_t aio; /* aio */ #endif ngx_flag_t tcp_nopush; /* tcp_nopush */ ngx_flag_t tcp_nodelay; /* tcp_nodelay */ ngx_flag_t reset_timedout_connection; /* reset_timedout_connection */ ngx_flag_t server_name_in_redirect; /* server_name_in_redirect */ ngx_flag_t port_in_redirect; /* port_in_redirect */ ngx_flag_t msie_padding; /* msie_padding */ ngx_flag_t msie_refresh; /* msie_refresh */ ngx_flag_t log_not_found; /* log_not_found */ ngx_flag_t log_subrequest; /* log_subrequest */ ngx_flag_t recursive_error_pages; /* recursive_error_pages */ ngx_flag_t server_tokens; /* server_tokens */ ngx_flag_t chunked_transfer_encoding; /* chunked_transfer_encoding */ ngx_flag_t etag; /* etag */ #if (NGX_HTTP_GZIP) ngx_flag_t gzip_vary; /* gzip_vary */ ngx_uint_t gzip_http_version; /* gzip_http_version */ ngx_uint_t gzip_proxied; /* gzip_proxied */ #if (NGX_PCRE) ngx_array_t *gzip_disable; /* gzip_disable */ #endif #endif #if (NGX_HAVE_OPENAT) ngx_uint_t disable_symlinks; /* disable_symlinks */ ngx_http_complex_value_t *disable_symlinks_from; #endif ngx_array_t *error_pages; /* error_page */ ngx_http_try_file_t *try_files; /* try_files */ ngx_path_t *client_body_temp_path; /* client_body_temp_path */ ngx_open_file_cache_t *open_file_cache; time_t open_file_cache_valid; ngx_uint_t open_file_cache_min_uses; ngx_flag_t open_file_cache_errors; ngx_flag_t open_file_cache_events; ngx_log_t *error_log; ngx_uint_t types_hash_max_size; ngx_uint_t types_hash_bucket_size; /* 将同一个server{}块内多个表达location{}块的ngx_http_core_loc_conf_t 结构体以双向链表方式组织, * 该指针指向ngx_http_location_queue_t结构体 */ ngx_queue_t *locations; #if 0 ngx_http_core_loc_conf_t *prev_location; #endif }; typedef struct{ /* 作为ngx_queue_t 双向链表容器,将ngx_http_location_queue_t结构体连接起来 */ ngx_queue_t queue; /* 若location中字符串可以精确匹配(包括正则表达式), * exact将指向对应的ngx_http_core_loc_conf_t结构体,否则为NULL */ ngx_http_core_loc_conf_t *exact; /* 若location中字符串无精确匹配(包括自定义通配符), * inclusive将指向对应的ngx_http_core_loc_conf_t结构体,否则为NULL */ ngx_http_core_loc_conf_t *inclusive; /* 指向location的名称 */ ngx_str_t *name; ... }ngx_http_location_queue_t;
ngx_http_core_module 模块定义
ngx_http_core_module 模块是 HTTP 模块中的第一个模块,该模块管理 srv、loc 级别的配置项结构。该模块在文件src/http/ngx_http_core_module.c中定义:
ngx_module_t ngx_http_core_module = { NGX_MODULE_V1, &ngx_http_core_module_ctx, /* module context */ ngx_http_core_commands, /* module directives */ NGX_HTTP_MODULE, /* module type */ NULL, /* init master */ NULL, /* init module */ NULL, /* init process */ NULL, /* init thread */ NULL, /* exit thread */ NULL, /* exit process */ NULL, /* exit master */ NGX_MODULE_V1_PADDING };
在模块的定义中,其中定义了 HTTP 模块的上下文结构 ngx_http_core_module_ctx,该上下文结构体定义如下:
static ngx_http_module_t ngx_http_core_module_ctx = { ngx_http_core_preconfiguration, /* preconfiguration */ NULL, /* postconfiguration */ ngx_http_core_create_main_conf, /* create main configuration */ ngx_http_core_init_main_conf, /* init main configuration */ ngx_http_core_create_srv_conf, /* create server configuration */ ngx_http_core_merge_srv_conf, /* merge server configuration */ ngx_http_core_create_loc_conf, /* create location configuration */ ngx_http_core_merge_loc_conf /* merge location configuration */ };
由于该模块中感兴趣的配置项太多,这里只列出 server、location 配置项。定义如下:
... { ngx_string("server"), NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS, ngx_http_core_server, 0, 0, NULL }, ... { ngx_string("location"), NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE12, ngx_http_core_location, NGX_HTTP_SRV_CONF_OFFSET, 0, NULL }, ... ngx_null_command };
管理 HTTP 模块不同级别的配置项结构体
在 HTTP 模块的 http{} 配置项解析过程中,可能遇到多个嵌套 server{} 块以及location{},不同块之间的解析都会创建相应的结构体保存配置项参数,但是由于属于嵌套关系,所有必须管理好不同块之间的配置项结构体,方便解析完毕后合并相应的配置项,以下针对不同级别的配置项结构体进行分析。
main 级别的配置项结构体
在 ngx_http_module 模块 http{} 块配置项解析的初始化过程中由函数 ngx_http_block 实现,在实现过程中创建并初始化了HTTP 模块 main 级别的配置项 main_conf、srv_conf、loc_conf 结构体。main 级别的配置项结构体之间的关系如下图所示:
server 级别的配置项结构体
在