Chinaunix首页 | 论坛 | 博客

mizhouli

首页　| 　博文目录　| 　关于我

mizhouli

  • 博客访问： 65156
  • 博文数量： 15
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 160
  • 用 户 组： 普通用户
  • 注册时间： 2014-11-04 17:12
个人简介

It

文章分类

全部博文（15）

文章存档

2015年（13）

2014年（2）

我的朋友
最近访客
推荐博文
相关博文
nginx配置文件解析

分类： LINUX

2015-07-06 12:43:32

1. nginx配置说明

nginx的配置文件在nginx系统中占有非常重要地位。
nginx的配置文件，它具有层次性。可以树来表示nginx的配置文件，假想一个树根ROOT，配置文件中配置命令 daemon、event、http等，是ROOT的孩子，而event、http又有自己的孩子。如下图：

 



2. nginx配置文件解析

nginx对配置的解析处理就是对该配置树进行递归的深度优先遍历出各个配置命令，然后对每个配置指令进行处理。

现在看一下nginx源码是如何解析配置文件的。

--main
 --ngx_init_cycle
   --ngx_conf_parse

2.1 ngx_cycle_init

nginx对配置文件的解析，对复杂的应该是http部分的解析处理。http部分的配置解析是当遇到'http'配置命令开始的，从上面的配置树中，我知道http部分的配置指令又分为多个层次
http server location等。

点击(此处)折叠或打开

  1. ngx_cycle_t *
  2. ngx_init_cycle(ngx_cycle_t *old_cycle)
  3. {
  4.     // ......
  5.     ngx_conf_t conf;
  6.     
  7.     // ......
  8.     
  9.     // 设置配置上下文
  10.     conf.ctx = cycle->conf_ctx;
  11.     conf.cycle = cycle;
  12.     conf.pool = pool;
  13.     conf.log = log;
  14.     conf.module_type = NGX_CORE_MODULE; //
  15.     conf.cmd_type = NGX_MAIN_CONF;

  17. #if 0
  18.     log->log_level = NGX_LOG_DEBUG_ALL;
  19. #endif

  21.     if (ngx_conf_param(&conf) != NGX_CONF_OK) {
  22.         environ = senv;
  23.         ngx_destroy_cycle_pools(&conf);
  24.         return NULL;
  25.     }

  27.     if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {
  28.         environ = senv;
  29.         ngx_destroy_cycle_pools(&conf);
  30.         return NULL;
  31.     }
  32.     // 至此，配置文件已经解析完毕
  33.     
  34.     // ......
  35. }
'http'配置指令属于 ngx_http_module 核心模块。该核心模块作为http部分的代理，是nginx系统处理http部分的入口。

点击(此处)折叠或打开

  1. static ngx_command_t ngx_http_commands[] = {

  3.     { ngx_string("http"),
  4.       NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  5.       ngx_http_block,
  6.       0,
  7.       0,
  8.       NULL },

  10.       ngx_null_command
  11. };


  14. static ngx_core_module_t ngx_http_module_ctx = {
  15.     ngx_string("http"),
  16.     NULL,
  17.     NULL
  18. };


  21. ngx_module_t ngx_http_module = {
  22.     NGX_MODULE_V1,
  23.     &ngx_http_module_ctx, /* module context */
  24.     ngx_http_commands, /* module directives */
  25.     NGX_CORE_MODULE, /* module type */
  26.     NULL, /* init master */
  27.     NULL, /* init module */
  28.     NULL, /* init process */
  29.     NULL, /* init thread */
  30.     NULL, /* exit thread */
  31.     NULL, /* exit process */
  32.     NULL, /* exit master */
  33.     NGX_MODULE_V1_PADDING
  34. };

2.2 ngx_http_block
当遇到'http'配置命令是，nginx的调用 ngx_http_block()进行处理：

点击(此处)折叠或打开

  1. static char *
  2. ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3. {
  4.     char *rv;
  5.     ngx_uint_t mi, m, s;
  6.     ngx_conf_t pcf;
  7.     ngx_http_module_t *module;
  8.     ngx_http_conf_ctx_t *ctx;
  9.     ngx_http_core_loc_conf_t *clcf;
  10.     ngx_http_core_srv_conf_t **cscfp;
  11.     ngx_http_core_main_conf_t *cmcf;

  13.     /* the main http context */
  14.     /*
  15.      * typedef struct {
  16.      * void **main_conf;
  17.      * void **srv_conf;
  18.      * void **loc_conf;
  19.      * } ngx_http_conf_ctx_t;
  20.      * ctx == ngx_http_conf_ctx_t
  21.      * main_conf -> [ m0 ] [ m1 ] ... [ ngx_http_max_module - 1]
  22.      * srv_conf -> [ s0 ] [ s1 ] ... [ ngx_http_max_module - 1]
  23.      * loc_conf -> [ l0 ] [ l1 ] ... [ ngx_http_max_module - 1]
  24.      */
  25.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  26.     if (ctx == NULL) {
  27.         return NGX_CONF_ERROR;
  28.     }

  30.     // 保存到 cycle->conf_ctx[ngx_http_module.index] 中
  31.     *(ngx_http_conf_ctx_t **) conf = ctx;


  34.     /* count the number of the http modules and set up their indices */

  36.     ngx_http_max_module = 0;
  37.     for (m = 0; ngx_modules[m]; m++) {
  38.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
  39.             continue;
  40.         }

  42.         ngx_modules[m]->ctx_index = ngx_http_max_module++;
  43.     }


  46.     /* the http main_conf context, it is the same in the all http contexts */
  47.     // main_conf -> [ m0 ] [ m1 ] ... [ ngx_http_max_module - 1]

  49.     ctx->main_conf = ngx_pcalloc(cf->pool,
  50.                                  sizeof(void *) * ngx_http_max_module);
  51.     if (ctx->main_conf == NULL) {
  52.         return NGX_CONF_ERROR;
  53.     }


  56.     /*
  57.      * the http null srv_conf context, it is used to merge
  58.      * the server{}s' srv_conf's
  59.      */
  60.     // srv_conf -> [ s0 ] [ s1 ] ... [ ngx_http_max_module - 1]

  62.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  63.     if (ctx->srv_conf == NULL) {
  64.         return NGX_CONF_ERROR;
  65.     }


  68.     /*
  69.      * the http null loc_conf context, it is used to merge
  70.      * the server{}s' loc_conf's
  71.      */
  72.     // loc_conf -> [ l0 ] [ l1 ] ... [ ngx_http_max_module - 1]
  73.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  74.     if (ctx->loc_conf == NULL) {
  75.         return NGX_CONF_ERROR;
  76.     }
  77.     


  80.     /*
  81.      * create the main_conf's, the null srv_conf's, and the null loc_conf's
  82.      * of the all http modules
  83.      */
  84.     //
  85.     for (m = 0; ngx_modules[m]; m++) {
  86.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
  87.             continue;
  88.         }

  90.         module = ngx_modules[m]->ctx;
  91.         mi = ngx_modules[m]->ctx_index;

  93.         if (module->create_main_conf) {
  94.             ctx->main_conf[mi] = module->create_main_conf(cf);
  95.             if (ctx->main_conf[mi] == NULL) {
  96.                 return NGX_CONF_ERROR;
  97.             }
  98.         }

  100.         if (module->create_srv_conf) {
  101.             ctx->srv_conf[mi] = module->create_srv_conf(cf);
  102.             if (ctx->srv_conf[mi] == NULL) {
  103.                 return NGX_CONF_ERROR;
  104.             }
  105.         }

  107.         if (module->create_loc_conf) {
  108.             ctx->loc_conf[mi] = module->create_loc_conf(cf);
  109.             if (ctx->loc_conf[mi] == NULL) {
  110.                 return NGX_CONF_ERROR;
  111.             }
  112.         }
  113.     }

  115.     // 保存父配置的上下文
  116.     pcf = *cf;
  117.     // 修改为当前配置的上下文
  118.     cf->ctx = ctx;

  120.     for (m = 0; ngx_modules[m]; m++) {
  121.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
  122.             continue;
  123.         }

  125.         module = ngx_modules[m]->ctx;

  127.         if (module->preconfiguration) {
  128.             if (module->preconfiguration(cf) != NGX_OK) {
  129.                 return NGX_CONF_ERROR;
  130.             }
  131.         }
  132.     }

  134.     /* parse inside the http{} block */

  136.     
  137.     cf->module_type = NGX_HTTP_MODULE;
  138.     cf->cmd_type = NGX_HTTP_MAIN_CONF;
  139.     // 递归解析 'http' 子树部分的配置命令
  140.     rv = ngx_conf_parse(cf, NULL);
  141.     
  142.     // 至此， 'http'子树的配置命令解析完毕
  143.     
  144.     // ......
  145. }

2.3 ngx_http_core_server
当 ngx_http_block 中调用 ngx_conf_parse(), 如果遇到 'server' 配置指令，则会调用 ngx_http_core_server.

点击(此处)折叠或打开

  1. static char *
  2. ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  3. {
  4.     char *rv;
  5.     void *mconf;
  6.     ngx_uint_t i;
  7.     ngx_conf_t pcf;
  8.     ngx_http_module_t *module;
  9.     struct sockaddr_in *sin;
  10.     ngx_http_conf_ctx_t *ctx, *http_ctx;
  11.     ngx_http_listen_opt_t lsopt;
  12.     ngx_http_core_srv_conf_t *cscf, **cscfp;
  13.     ngx_http_core_main_conf_t *cmcf;

  15.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  16.     if (ctx == NULL) {
  17.         return NGX_CONF_ERROR;
  18.     }

  20.     
  21.     http_ctx = cf->ctx;
  22.     ctx->main_conf = http_ctx->main_conf;

  24.     /* the server{}'s srv_conf */

  26.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  27.     if (ctx->srv_conf == NULL) {
  28.         return NGX_CONF_ERROR;
  29.     }

  31.     /* the server{}'s loc_conf */

  33.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  34.     if (ctx->loc_conf == NULL) {
  35.         return NGX_CONF_ERROR;
  36.     }

  38.     for (i = 0; ngx_modules[i]; i++) {
  39.         if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
  40.             continue;
  41.         }

  43.         module = ngx_modules[i]->ctx;

  45.         if (module->create_srv_conf) {
  46.             mconf = module->create_srv_conf(cf);
  47.             if (mconf == NULL) {
  48.                 return NGX_CONF_ERROR;
  49.             }

  51.             ctx->srv_conf[ngx_modules[i]->ctx_index] = mconf;
  52.         }

  54.         if (module->create_loc_conf) {
  55.             mconf = module->create_loc_conf(cf);
  56.             if (mconf == NULL) {
  57.                 return NGX_CONF_ERROR;
  58.             }

  60.             ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
  61.         }
  62.     }


  65.     cscf = ctx->srv_conf[ngx_http_core_module.ctx_index];
  66.     cscf->ctx = ctx;


  69.     cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];

  71.     cscfp = ngx_array_push(&cmcf->servers);
  72.     if (cscfp == NULL) {
  73.         return NGX_CONF_ERROR;
  74.     }
  75.     *cscfp = cscf;


  78.     pcf = *cf;
  79.     cf->ctx = ctx;
  80.     cf->cmd_type = NGX_HTTP_SRV_CONF;

  82.     // 递归调用 ngx_conf_parse ，解析 'server' 配置块(或者配置子树)中的命令
  83.     rv = ngx_conf_parse(cf, NULL);
  84.     // 至此，该'server'块下的配置命令解析完毕

  86.     // 回复为父亲的配置上下文
  87.     *cf = pcf;

  89.     if (rv == NGX_CONF_OK && !cscf->listen) {
  90.         // 如果该server配置块未配置为listen，则使用默认的端口 80/8000
  91.         ngx_memzero(&lsopt, sizeof(ngx_http_listen_opt_t));

  93.         sin = &lsopt.u.sockaddr_in;

  95.         sin->sin_family = AF_INET;
  96. #if (NGX_WIN32)
  97.         sin->sin_port = htons(80);
  98. #else
  99.         sin->sin_port = htons((getuid() == 0) ? 80 : 8000);
  100. #endif
  101.         sin->sin_addr.s_addr = INADDR_ANY;

  103.         lsopt.socklen = sizeof(struct sockaddr_in);

  105.         lsopt.backlog = NGX_LISTEN_BACKLOG;
  106.         lsopt.rcvbuf = -1;
  107.         lsopt.sndbuf = -1;
  108. #if (NGX_HAVE_SETFIB)
  109.         lsopt.setfib = -1;
  110. #endif
  111.         lsopt.wildcard = 1;

  113.         (void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.socklen, lsopt.addr,
  114.                              NGX_SOCKADDR_STRLEN, 1);

  116.         if (ngx_http_add_listen(cf, cscf, &lsopt) != NGX_OK) {
  117.             return NGX_CONF_ERROR;
  118.         }
  119.     }

  121.     return rv;
  122. }

2.4  ngx_http_core_location
当 ngx_http_core_server 中调用 ngx_conf_parse(), 如果遇到 'location' 配置指令，则会调用 ngx_http_core_location .

点击(此处)折叠或打开

  1. static char *
  2. ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  3. {
  4.     char *rv;
  5.     u_char *mod;
  6.     size_t len;
  7.     ngx_str_t *value, *name;
  8.     ngx_uint_t i;
  9.     ngx_conf_t save;
  10.     ngx_http_module_t *module;
  11.     ngx_http_conf_ctx_t *ctx, *pctx;
  12.     ngx_http_core_loc_conf_t *clcf, *pclcf;

  14.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  15.     if (ctx == NULL) {
  16.         return NGX_CONF_ERROR;
  17.     }

  19.     pctx = cf->ctx;
  20.     ctx->main_conf = pctx->main_conf;
  21.     ctx->srv_conf = pctx->srv_conf;

  23.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  24.     if (ctx->loc_conf == NULL) {
  25.         return NGX_CONF_ERROR;
  26.     }

  28.     for (i = 0; ngx_modules[i]; i++) {
  29.         if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
  30.             continue;
  31.         }

  33.         module = ngx_modules[i]->ctx;

  35.         if (module->create_loc_conf) {
  36.             ctx->loc_conf[ngx_modules[i]->ctx_index] =
  37.                                                    module->create_loc_conf(cf);
  38.             if (ctx->loc_conf[ngx_modules[i]->ctx_index] == NULL) {
  39.                  return NGX_CONF_ERROR;
  40.             }
  41.         }
  42.     }

  44.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  45.     clcf->loc_conf = ctx->loc_conf;

  47.     value = cf->args->elts;

  49.     if (cf->args->nelts == 3) {

  51.         len = value[1].len;
  52.         mod = value[1].data;
  53.         name = &value[2];

  55.         if (len == 1 && mod[0] == '=') { // location = /a/b

  57.             clcf->name = *name;
  58.             clcf->exact_match = 1;

  60.         } else if (len == 2 && mod[0] == '^' && mod[1] == '~') { // location ^~ /a/b

  62.             clcf->name = *name;
  63.             clcf->noregex = 1;

  65.         } else if (len == 1 && mod[0] == '~') { // location ~ /a/b

  67.             if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  68.                 return NGX_CONF_ERROR;
  69.             }

  71.         } else if (len == 2 && mod[0] == '~' && mod[1] == '*') {// location = /a/b

  73.             if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  74.                 return NGX_CONF_ERROR;
  75.             }

  77.         } else {
  78.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  79.                                "invalid location modifier \"%V\"", &value[1]);
  80.             return NGX_CONF_ERROR;
  81.         }

  83.     } else {

  85.         name = &value[1];

  87.         if (name->data[0] == '=') {

  89.             clcf->name.len = name->len - 1;
  90.             clcf->name.data = name->data + 1;
  91.             clcf->exact_match = 1;

  93.         } else if (name->data[0] == '^' && name->data[1] == '~') {

  95.             clcf->name.len = name->len - 2;
  96.             clcf->name.data = name->data + 2;
  97.             clcf->noregex = 1;

  99.         } else if (name->data[0] == '~') {

  101.             name->len--;
  102.             name->data++;

  104.             if (name->data[0] == '*') {

  106.                 name->len--;
  107.                 name->data++;

  109.                 if (ngx_http_core_regex_location(cf, clcf, name, 1) != NGX_OK) {
  110.                     return NGX_CONF_ERROR;
  111.                 }

  113.             } else {
  114.                 if (ngx_http_core_regex_location(cf, clcf, name, 0) != NGX_OK) {
  115.                     return NGX_CONF_ERROR;
  116.                 }
  117.             }

  119.         } else {

  121.             clcf->name = *name;

  123.             if (name->data[0] == '@') {
  124.                 clcf->named = 1;
  125.             }
  126.         }
  127.     }

  129.     pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];

  131.     if (pclcf->name.len) {

  133.         /* nested location */

  135. #if 0
  136.         clcf->prev_location = pclcf;
  137. #endif

  139.         if (pclcf->exact_match) {
  140.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  141.                                "location \"%V\" cannot be inside "
  142.                                "the exact location \"%V\"",
  143.                                &clcf->name, &pclcf->name);
  144.             return NGX_CONF_ERROR;
  145.         }

  147.         if (pclcf->named) {
  148.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  149.                                "location \"%V\" cannot be inside "
  150.                                "the named location \"%V\"",
  151.                                &clcf->name, &pclcf->name);
  152.             return NGX_CONF_ERROR;
  153.         }

  155.         if (clcf->named) {
  156.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  157.                                "named location \"%V\" can be "
  158.                                "on the server level only",
  159.                                &clcf->name);
  160.             return NGX_CONF_ERROR;
  161.         }

  163.         len = pclcf->name.len;

  165. #if (NGX_PCRE)
  166.         if (clcf->regex == NULL
  167.             && ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  168. #else
  169.         if (ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
  170. #endif
  171.         {
  172.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  173.                                "location \"%V\" is outside location \"%V\"",
  174.                                &clcf->name, &pclcf->name);
  175.             return NGX_CONF_ERROR;
  176.         }
  177.     }

  179.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  180.         return NGX_CONF_ERROR;
  181.     }

  183.     // 保存父配置上下文信息
  184.     save = *cf;
  185.     // 设置该部分的配置上下文信息
  186.     cf->ctx = ctx;
  187.     cf->cmd_type = NGX_HTTP_LOC_CONF;

  189.     // 递归调用， 解析 'location' 配置块(子树)的配置命令
  190.     rv = ngx_conf_parse(cf, NULL);
  191.     // 至此,该 'location' 配置块(子树)的配置命令解析完毕

  193.     // 回复为父亲的配置上下文
  194.     *cf = save;

  196.     return rv;
  197. }

2.5 总结
可以看出，nginx的配置文件的解析处理是按照深度优先遍历配置文件的各个配置命令。

当ngx_http_block()中 ngx_conf_parse() 返回后，整个 'http'块(子树)的所有的配置命令解析完毕。此时，nginx保存的配置信息的内存布局如下图所示。

3. ngx_http_block 解析完http配置块后的处理
从代码以及图中可以看出，http层次既有main_conf，也有srv_conf、loc_conf；server层既有srv_conf，也有 loc_conf; location层，有 loc_conf，还可能有 nested locaton层的配置。这就需要把相关部分的配置信息进行合并。

点击(此处)折叠或打开

  1. static char *
  2. ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3. {
  4.     // http 配置块解析完毕
  5.     
  6.     if (rv != NGX_CONF_OK) {
  7.         goto failed;
  8.     }

  10.     /*
  11.      * init http{} main_conf's, merge the server{}s' srv_conf's
  12.      * and its location{}s' loc_conf's
  13.      */

  15.     cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
  16.     cscfp = cmcf->servers.elts;

  18.     for (m = 0; ngx_modules[m]; m++) {
  19.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
  20.             continue;
  21.         }

  23.         module = ngx_modules[m]->ctx;
  24.         mi = ngx_modules[m]->ctx_index;

  26.         /* init http{} main_conf's */

  28.         if (module->init_main_conf) {
  29.             rv = module->init_main_conf(cf, ctx->main_conf[mi]);
  30.             if (rv != NGX_CONF_OK) {
  31.                 goto failed;
  32.             }
  33.         }

  35.         // 合并server的配置信息，该函数会继续调用合并location的配置信息
  36.         rv = ngx_http_merge_servers(cf, cmcf, module, mi);//
  37.         if (rv != NGX_CONF_OK) {
  38.             goto failed;
  39.         }
  40.     }


  43.     /* create location trees */

  45.     // 对各个server下的location配置信息进行整理，其目的是后面对location进行查询时，
  46.     // 效率尽可能的高
  47.     for (s = 0; s < cmcf->servers.nelts; s++) {

  49.         // clcf鎸囧悜ngx_http_core_module鐨剆rv绾у埆鐨刲ocation淇℃伅
  50.         clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];

  52.         // 后续blog进行分析
  53.         if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) {
  54.             return NGX_CONF_ERROR;
  55.         }

  57.         // 后续blog进行分析
  58.         if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
  59.             return NGX_CONF_ERROR;
  60.         }
  61.     }

  63.     // ngx把对 接受完http请求后的处理分为11个处理阶段，
  64.     // 也就是说可以在这个11个阶段注册各个模块的钩子函数，
  65.     // 使模块参与处理http业务。
  66.     if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
  67.         return NGX_CONF_ERROR;
  68.     }

  70.     
  71.     // cmcf->headers_in_hash
  72.     if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) {
  73.         return NGX_CONF_ERROR;
  74.     }


  77.     for (m = 0; ngx_modules[m]; m++) {
  78.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
  79.             continue;
  80.         }

  82.         module = ngx_modules[m]->ctx;

  84.         if (module->postconfiguration) {
  85.             // 上面已经初始化好了各个阶段，
  86.             // 各个模块可以根据需要插入相应阶段的处理函数
  87.             if (module->postconfiguration(cf) != NGX_OK) {
  88.                 return NGX_CONF_ERROR;
  89.             }
  90.         }
  91.     }

  93.     if (ngx_http_variables_init_vars(cf) != NGX_OK) {
  94.         return NGX_CONF_ERROR;
  95.     }

  97.     /*
  98.      * http{}


至此整个http部分的配置解析完毕，理解了该部分配置信息的处理，其他配置信息可以很容易理解了。

 

阅读(2715) | 评论(0) | 转发(0) |
0

上一篇：如何避免 TCP 自连接

下一篇：http协议 Content-Encoding Content-Length Transfer-Encoding 三头部的理解

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6