Nginx中的HTTP協議相關模塊怎么配置

這篇文章主要介紹了Nginx中的HTTP協議相關模塊怎么配置的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Nginx中的HTTP協議相關模塊怎么配置文章都會有所收獲，下面我們一起來看看吧。

要理解 http 模塊配置解析的過程，首先需要對 nginx 的配置文件結構做一個了解

nginx 的配置文件是用樹狀結構組織的，每個 ngx_core_module 作為根統領著其下的所有配置項

而如下圖所示，http 模塊的配置被分成了 main、server、location 三層

整個 nginx 配置解析的過程其實就是這棵樹的深度遍歷過程

而遍歷 http 子樹的函數就是下面要介紹的 ngx_http_block

配置文件解析 -- http 配置塊
當我們需要使用 http 模塊的時候，我們需要在配置文件中加入 http 配置塊：

http { // http 配置塊 {{{
  include    mime.types;
  default_type application/octet-stream;
  #log_format main '$remote_addr - $remote_user [$time_local] "$request" 
'
  #         '$status $body_bytes_sent "$http_referer" '
  #         '"$http_user_agent" "$http_x_forwarded_for"';
  #access_log logs/access.log main;
  sendfile    on;
  #tcp_nopush   on;
  #keepalive_timeout 0;
  keepalive_timeout 65;
  #gzip on;
  server {
    listen    8001;
    server_name localhost;
    #autoindex  on;
    #charset koi8-r;
    #access_log logs/host.access.log main;
    location / {
      root  /var/www/;
      index index.html index.htm index.php;

在 http 配置塊中，我們配置了 http 連接相關的信息，http 框架也正是從這里啟動的.

在 nginx 初始化的過程中，執行了 ngx_init_cycle 函數，其中進行了配置文件解析，調用了 ngx_conf_parse 函數

配置文件解析

函數 ngx_conf_handler 根據配置項的 command 調用了對應的 set 回調函數

// static ngx_int_t ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last)
// 配置項解析 {{{
static ngx_int_t
ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last)
{
  char      *rv;
  void      *conf, **confp;
  ngx_uint_t   i, found;
  ngx_str_t   *name;
  ngx_command_t *cmd;
  name = cf->args->elts;
  found = 0;
  for (i = 0; ngx_modules[i]; i++) {
    cmd = ngx_modules[i]->commands;
    if (cmd == null) {
      continue;
    }
    for ( /* void */ ; cmd->name.len; cmd++) {
      if (name->len != cmd->name.len) {
        continue;
      }
      if (ngx_strcmp(name->data, cmd->name.data) != 0) {
        continue;
      }

閱讀各模塊的 ngx_command_t 命令配置結構，可以找到：

// static ngx_command_t ngx_http_commands
// 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
}; // }}}

http 配置塊解析 -- ngx_http_block

在解析到 http 配置塊時，執行了對應的 set 回調函數 ngx_http_block

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 */

  ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  if (ctx == null) {
    return ngx_conf_error;
  }

 // 創建 http 配置結構，保存所有 http 模塊的配置信息
  *(ngx_http_conf_ctx_t **) conf = ctx;


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

  ngx_http_max_module = 0;
  for (m = 0; ngx_modules[m]; m++) {
    if (ngx_modules[m]->type != ngx_http_module) {
      continue;
    }

 // 重新設定 http 模塊序號
    ngx_modules[m]->ctx_index = ngx_http_max_module++;
  }


  /* 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;
  }


  /*
   * 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;
  }


  /*
   * 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
   */

  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;

    if (module->create_main_conf) {
  // 調用每個模塊的 create_main_conf 回調函數
  // 創建自己的 main_conf
  //
  // ngx_http_core_module  ngx_http_core_create_main_conf
  // ngx_http_log_module  ngx_http_log_create_main_conf
  // ngx_http_upstream_module  ngx_http_upstream_create_main_conf
  // ngx_http_map_module  ngx_http_map_create_conf
  // ngx_http_ssi_filter_module ngx_http_ssi_create_main_conf
  // ngx_http_charset_filter_module ngx_http_charset_create_main_conf
      ctx->main_conf[mi] = module->create_main_conf(cf);
      if (ctx->main_conf[mi] == null) {
        return ngx_conf_error;
      }
    }

    if (module->create_srv_conf) {
  // 調用每個模塊的 create_srv_conf 回調函數
  // 創建自己的 srv_conf
  //
  // ngx_http_core_module   ngx_http_core_create_srv_conf
  // ngx_http_ssl_module   ngx_http_ssl_create_srv_conf
  // ngx_http_upstream_hash_module ngx_http_upstream_hash_create_conf
  // ngx_http_upstream_least_conn_module ngx_http_upstream_least_conn_create_conf
  // ngx_http_upstream_keepalive_module ngx_http_upstream_keepalive_create_conf
      ctx->srv_conf[mi] = module->create_srv_conf(cf);
      if (ctx->srv_conf[mi] == null) {
        return ngx_conf_error;
      }
    }

    if (module->create_loc_conf) {
  // 調用每個模塊的 create_loc_conf 回調函數
  // 創建自己的 loc_conf
  //
  // ngx_http_core_module  ngx_http_core_create_loc_conf
  // ngx_http_log_module  ngx_http_log_create_loc_conf
  // ngx_http_gzip_static_module ngx_http_gzip_static_create_conf
  // ngx_http_autoindex_module ngx_http_autoindex_create_loc_conf
  // ngx_http_index_module  ngx_http_index_create_loc_conf
  // ngx_http_auth_basic_module ngx_http_auth_basic_create_loc_conf
  // ngx_http_access_module  ngx_http_access_create_loc_conf
  // ngx_http_limit_conn_module ngx_http_limit_conn_create_conf
  // ngx_http_limit_req_module ngx_http_limit_req_create_conf
  // ngx_http_referer_module  ngx_http_referer_create_conf
  // ngx_http_rewrite_module  ngx_http_rewrite_create_loc_conf
  // ngx_http_proxy_module  ngx_http_proxy_create_loc_conf
  // ngx_http_fastcgi_module  ngx_http_fastcgi_create_loc_conf
  // ngx_http_uwsgi_module  ngx_http_uwsgi_create_loc_conf
  // ngx_http_scgi_module  ngx_http_scgi_create_loc_conf
  // ngx_http_memcached_module ngx_http_memcached_create_loc_conf
  // ngx_http_browser_module  ngx_http_browser_create_conf
  // ngx_http_gzip_filter_module ngx_http_gzip_create_conf
  // ngx_http_ssi_filter_module ngx_http_ssi_create_loc_conf
  // ngx_http_charset_filter_module ngx_http_charset_create_loc_conf
  // ngx_http_userid_filter_module ngx_http_userid_create_conf
  // ngx_http_headers_filter_module ngx_http_headers_create_conf
  // ngx_http_copy_filter_module ngx_http_copy_filter_create_conf
      ctx->loc_conf[mi] = module->create_loc_conf(cf);
      if (ctx->loc_conf[mi] == null) {
        return ngx_conf_error;
      }
    }
  }

  pcf = *cf;
  cf->ctx = ctx;

  for (m = 0; ngx_modules[m]; m++) {
    if (ngx_modules[m]->type != ngx_http_module) {
      continue;
    }

    module = ngx_modules[m]->ctx;

    if (module->preconfiguration) {
  // 調用每個模塊的 preconfiguration 回調函數
  //
  // ngx_http_core_module  ngx_http_core_preconfiguration
  // ngx_http_upstream_module  ngx_http_upstream_add_variables
  // ngx_http_ssl_module  ngx_http_ssl_add_variables
  // ngx_http_proxy_module  ngx_http_proxy_add_variables
  // ngx_http_fastcgi_module  ngx_http_fastcgi_add_variables
  // ngx_http_browser_module  ngx_http_browser_add_variable
  // ngx_http_stub_status_module ngx_http_stub_status_add_variables
  // ngx_http_gzip_filter_module ngx_http_gzip_add_variables
  // ngx_http_ssi_filter_module ngx_http_ssi_preconfiguration
  // ngx_http_userid_filter_module ngx_http_userid_add_variables
      if (module->preconfiguration(cf) != ngx_ok) {
        return ngx_conf_error;
      }
    }
  }

  /* parse inside the http{} block */

  cf->module_type = ngx_http_module;
  cf->cmd_type = ngx_http_main_conf;
  rv = ngx_conf_parse(cf, null);

  if (rv != ngx_conf_ok) {
    goto failed;
  }

  /*
   * init http{} main_conf's, merge the server{}s' srv_conf's
   * and its location{}s' loc_conf's
   */

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

  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;

    /* init http{} main_conf's */

    if (module->init_main_conf) {
  // 調用每個模塊的 init_main_conf 回調函數
  // 初始化自己的 main_conf
  //
  // ngx_http_core_module  ngx_http_core_init_main_conf
  // ngx_http_upstream_module ngx_http_upstream_init_main_conf
  // ngx_http_ssi_filter_module ngx_http_ssi_init_main_conf
      rv = module->init_main_conf(cf, ctx->main_conf[mi]);
      if (rv != ngx_conf_ok) {
        goto failed;
      }
    }

 // 合并同名配置項
    rv = ngx_http_merge_servers(cf, cmcf, module, mi);
    if (rv != ngx_conf_ok) {
      goto failed;
    }
  }


  /* create location trees */

  for (s = 0; s < cmcf->servers.nelts; s++) {

    clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];

    if (ngx_http_init_locations(cf, cscfp[s], clcf) != ngx_ok) {
      return ngx_conf_error;
    }

    if (ngx_http_init_static_location_trees(cf, clcf) != ngx_ok) {
      return ngx_conf_error;
    }
  }


  if (ngx_http_init_phases(cf, cmcf) != ngx_ok) {
    return ngx_conf_error;
  }

  if (ngx_http_init_headers_in_hash(cf, cmcf) != ngx_ok) {
    return ngx_conf_error;
  }


  for (m = 0; ngx_modules[m]; m++) {
    if (ngx_modules[m]->type != ngx_http_module) {
      continue;
    }

    module = ngx_modules[m]->ctx;

    if (module->postconfiguration) {
  // 調用每個 http 模塊的 postconfiguration 回調函數
  //
  // ngx_http_log_module   ngx_http_log_init
  // ngx_http_static_module  ngx_http_static_init
  // ngx_http_gzip_static_module  ngx_http_gzip_static_init
  // ngx_http_autoindex_module  ngx_http_autoindex_init
  // ngx_http_index_module  ngx_http_index_init
  // ngx_http_auth_basic_module  ngx_http_auth_basic_init
  // ngx_http_access_module  ngx_http_access_init
  // ngx_http_limit_conn_module  ngx_http_limit_conn_init
  // ngx_http_limit_req_module  ngx_http_limit_req_init
  // ngx_http_rewrite_module  ngx_http_rewrite_init
  // ngx_http_ssl_module   ngx_http_ssl_init
  // ngx_http_write_filter_module  ngx_http_write_filter_init
  // ngx_http_header_filter_module ngx_http_header_filter_init
  // ngx_http_chunked_filter_module ngx_http_chunked_filter_init
  // ngx_http_range_body_filter_module ngx_http_range_body_filter_init
  // ngx_http_gzip_filter_module  ngx_http_gzip_filter_init
  // ngx_http_postpone_filter_module ngx_http_postpone_filter_init
  // ngx_http_ssi_filter_module  ngx_http_ssi_filter_init
  // ngx_http_charset_filter_module ngx_http_charset_postconfiguration
  // ngx_http_userid_filter_module ngx_http_userid_init
  // ngx_http_headers_filter_module ngx_http_headers_filter_init
  // ngx_http_copy_filter_module  ngx_http_copy_filter_init
  // ngx_http_range_body_filter_module ngx_http_range_body_filter_init
  // ngx_http_not_modified_filter_module ngx_http_not_modified_filter_init
      if (module->postconfiguration(cf) != ngx_ok) {
        return ngx_conf_error;
      }
    }
  }

 // 初始化所有的變量
 // 不僅包括http core模塊的變量
 // 也包括其他的http模塊導出的變量，以及配置文件中使用 set 命令設置的變量
 // 這里的初始化包括初始化hash表，以及初始化數組索引
  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 結構
  if (ngx_http_init_phase_handlers(cf, cmcf) != ngx_ok) {
    return ngx_conf_error;
  }


  /* optimize the lists of ports, addresses and server names */

 // 創建 http 連接，并設置為監聽狀態
  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 模塊都分配并創建了配置結構，同時，調用了每個模塊相應的初始化回調。

最后，調用 ngx_http_optimize_servers 創建了 http 連接，加入 cycle 的監聽數組，并設為監聽狀態。

nginx 配置文件對 http 模塊的配置分為三層：main、sever、location，因此，http 模塊上下文 ngx_http_module_t 中定義了以下六個回調函數，用來創建和保存配置信息：

• create_main_conf

• init_main_conf

• create_srv_conf

• merge_srv_conf

• create_loc_conf

• merge_loc_conf

在 ngx_http_block 中，循環調用了所有 ngx_http_module 的這六個回調函數，創建相關的配置結構。

server、location 配置解析 -- ngx_http_core_server、ngx_http_core_location
在調用所有 http 模塊的 create_main_conf、create_srv_conf、create_loc_conf 后，所有需要配置結構的模塊都完成了配置結構的創建，于是在調用所有模塊的 preconfiguration 回調函數后，配置解析工作正式展開

通過調用 ngx_conf_parse 函數，開始了 http 配置塊的解析，并通過解析到的命令調用相應的函數

在首個 ngx_http_module ngx_http_core_module 的 ngx_command_t 域中包含了大量的配置指令，它們都是在http{}塊中出現的，其中包括兩個重要的指令:

{ ngx_string("listen"),
 ngx_http_srv_conf|ngx_conf_1more,
 ngx_http_core_listen,
 ngx_http_srv_conf_offset,
 0,
 null },

{ 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 },

這里配置了 listen、server 與 location 塊的解析函數 ngx_http_core_listen、ngx_http_core_server 和 ngx_http_core_location.

server 塊解析 -- ngx_http_core_server

// static char *
// ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
// http server 塊解析 {{{
static char *
ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
{
  char            *rv;
  void            *mconf;
  ngx_uint_t          i;
  ngx_conf_t          pcf;
  ngx_http_module_t      *module;
  struct sockaddr_in     *sin;
  ngx_http_conf_ctx_t     *ctx, *http_ctx;
  ngx_http_listen_opt_t    lsopt;
  ngx_http_core_srv_conf_t  *cscf, **cscfp;
  ngx_http_core_main_conf_t  *cmcf;

  ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  if (ctx == null) {
    return ngx_conf_error;
  }

  http_ctx = cf->ctx;
  ctx->main_conf = http_ctx->main_conf;

  /* the server{}'s srv_conf */

 // 為所有 http 模塊分配空間存儲 srv_conf
  ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  if (ctx->srv_conf == null) {
    return ngx_conf_error;
  }

  /* the server{}'s loc_conf */

 // 為所有 http 模塊分配空間存儲 loc_conf
  ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  if (ctx->loc_conf == null) {
    return ngx_conf_error;
  }

 // 循環調用每個模塊的 create_srv_conf 與 create_loc_conf 回調，創建配置結構
  for (i = 0; ngx_modules[i]; i++) {
    if (ngx_modules[i]->type != ngx_http_module) {
      continue;
    }

    module = ngx_modules[i]->ctx;

    if (module->create_srv_conf) {
      mconf = module->create_srv_conf(cf);
      if (mconf == null) {
        return ngx_conf_error;
      }

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

    if (module->create_loc_conf) {
      mconf = module->create_loc_conf(cf);
      if (mconf == null) {
        return ngx_conf_error;
      }

      ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
    }
  }


  /* the server configuration context */

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


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

  cscfp = ngx_array_push(&cmcf->servers);
  if (cscfp == null) {
    return ngx_conf_error;
  }

  *cscfp = cscf;


  /* parse inside server{} */

  pcf = *cf;
  cf->ctx = ctx;
  cf->cmd_type = ngx_http_srv_conf;

 // 解析 server 塊配置
  rv = ngx_conf_parse(cf, null);

  *cf = pcf;

 // 如果沒有監聽任何端口，則監聽默認的 80 或 8000端口
  if (rv == ngx_conf_ok && !cscf->listen) {
    ngx_memzero(&lsopt, sizeof(ngx_http_listen_opt_t));

    sin = &lsopt.u.sockaddr_in;

    sin->sin_family = af_inet;
#if (ngx_win32)
    sin->sin_port = htons(80);
#else
    sin->sin_port = htons((getuid() == 0) ? 80 : 8000);
#endif
    sin->sin_addr.s_addr = inaddr_any;

    lsopt.socklen = sizeof(struct sockaddr_in);

    lsopt.backlog = ngx_listen_backlog;
    lsopt.rcvbuf = -1;
    lsopt.sndbuf = -1;
#if (ngx_have_setfib)
    lsopt.setfib = -1;
#endif
#if (ngx_have_tcp_fastopen)
    lsopt.fastopen = -1;
#endif
    lsopt.wildcard = 1;

    (void) ngx_sock_ntop(&lsopt.u.sockaddr, lsopt.socklen, lsopt.addr,
               ngx_sockaddr_strlen, 1);

    if (ngx_http_add_listen(cf, cscf, &lsopt) != ngx_ok) {
      return ngx_conf_error;
    }
  }

  return rv;
} // }}}

location 塊解析 -- ngx_http_core_location

// static char *
// ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
// location 塊配置解析 {{{
static char *
ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
{
  char           *rv;
  u_char          *mod;
  size_t           len;
  ngx_str_t         *value, *name;
  ngx_uint_t         i;
  ngx_conf_t         save;
  ngx_http_module_t     *module;
  ngx_http_conf_ctx_t    *ctx, *pctx;
  ngx_http_core_loc_conf_t *clcf, *pclcf;

  ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  if (ctx == null) {
    return ngx_conf_error;
  }

  pctx = cf->ctx;
  ctx->main_conf = pctx->main_conf;
  ctx->srv_conf = pctx->srv_conf;

  ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  if (ctx->loc_conf == null) {
    return ngx_conf_error;
  }

  for (i = 0; ngx_modules[i]; i++) {
    if (ngx_modules[i]->type != ngx_http_module) {
      continue;
    }

    module = ngx_modules[i]->ctx;

    if (module->create_loc_conf) {
      ctx->loc_conf[ngx_modules[i]->ctx_index] =
                          module->create_loc_conf(cf);
      if (ctx->loc_conf[ngx_modules[i]->ctx_index] == null) {
         return ngx_conf_error;
      }
    }
  }

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

  value = cf->args->elts;

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

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

    if (len == 1 && mod[0] == '=') {

      clcf->name = *name;
      clcf->exact_match = 1;

    } else if (len == 2 && mod[0] == '^' && mod[1] == '~') {

      clcf->name = *name;
      clcf->noregex = 1;

    } else if (len == 1 && mod[0] == '~') {

      if (ngx_http_core_regex_location(cf, clcf, name, 0) != ngx_ok) {
        return ngx_conf_error;
      }

    } else if (len == 2 && mod[0] == '~' && mod[1] == '*') {

      if (ngx_http_core_regex_location(cf, clcf, name, 1) != ngx_ok) {
        return ngx_conf_error;
      }

    } else {
      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "invalid location modifier \"%v\"", &value[1]);
      return ngx_conf_error;
    }

  } else {

    name = &value[1];

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

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

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

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

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

      name->len--;
      name->data++;

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

        name->len--;
        name->data++;

        if (ngx_http_core_regex_location(cf, clcf, name, 1) != ngx_ok) {
          return ngx_conf_error;
        }

      } else {
        if (ngx_http_core_regex_location(cf, clcf, name, 0) != ngx_ok) {
          return ngx_conf_error;
        }
      }

    } else {

      clcf->name = *name;

      if (name->data[0] == '@') {
        clcf->named = 1;
      }
    }
  }

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

  if (pclcf->name.len) {

    /* nested location */

#if 0
    clcf->prev_location = pclcf;
#endif

    if (pclcf->exact_match) {
      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "location \"%v\" cannot be inside "
                "the exact location \"%v\"",
                &clcf->name, &pclcf->name);
      return ngx_conf_error;
    }

    if (pclcf->named) {
      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "location \"%v\" cannot be inside "
                "the named location \"%v\"",
                &clcf->name, &pclcf->name);
      return ngx_conf_error;
    }

    if (clcf->named) {
      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "named location \"%v\" can be "
                "on the server level only",
                &clcf->name);
      return ngx_conf_error;
    }

    len = pclcf->name.len;

#if (ngx_pcre)
    if (clcf->regex == null
      && ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
#else
    if (ngx_filename_cmp(clcf->name.data, pclcf->name.data, len) != 0)
#endif
    {
      ngx_conf_log_error(ngx_log_emerg, cf, 0,
                "location \"%v\" is outside location \"%v\"",
                &clcf->name, &pclcf->name);
      return ngx_conf_error;
    }
  }

 // 將 location 配置加入到 locations 配置鏈表中
  if (ngx_http_add_location(cf, &pclcf->locations, clcf) != ngx_ok) {
    return ngx_conf_error;
  }

  save = *cf;
  cf->ctx = ctx;
  cf->cmd_type = ngx_http_loc_conf;

  rv = ngx_conf_parse(cf, null);

  *cf = save;

  return rv;
} // }}}

與 server 塊解析函數 ngx_http_core_server 類似，他創建了所有模塊的 loc_conf，為了防止內外層具有相同指令，在配置賦值完成后，會通過 merge 函數合并到一起。

然而，與 server 塊不同，location 塊在 location 后面會通過路徑或正則表達式指定 location 配置的應用 uri，因此，在 ngx_http_core_location 函數中調用 pcre 進行了 location 命令的解析。

解析完成后調用 ngx_http_add_location 將解析結果加入到 locations 鏈表中。

// ngx_int_t ngx_http_add_location(ngx_conf_t *cf, ngx_queue_t **locations,
//   ngx_http_core_loc_conf_t *clcf)
// 將 location 配置加入到 locations 配置鏈表中 {{{
ngx_int_t
ngx_http_add_location(ngx_conf_t *cf, ngx_queue_t **locations,
  ngx_http_core_loc_conf_t *clcf)
{
  ngx_http_location_queue_t *lq;

  if (*locations == null) {
    *locations = ngx_palloc(cf->temp_pool,
                sizeof(ngx_http_location_queue_t));
    if (*locations == null) {
      return ngx_error;
    }

    ngx_queue_init(*locations);
  }

  lq = ngx_palloc(cf->temp_pool, sizeof(ngx_http_location_queue_t));
  if (lq == null) {
    return ngx_error;
  }

  if (clcf->exact_match
#if (ngx_pcre)
    || clcf->regex
#endif
    || clcf->named || clcf->noname)
  {
    lq->exact = clcf;
    lq->inclusive = null;

  } else {
    lq->exact = null;
    lq->inclusive = clcf;
  }

  lq->name = &clcf->name;
  lq->file_name = cf->conf_file->file.name.data;
  lq->line = cf->conf_file->line;

  ngx_queue_init(&lq->list);

  ngx_queue_insert_tail(*locations, &lq->queue);

  return ngx_ok;
} // }}}

配置解析全部完成后的配置結構。

關于“Nginx中的HTTP協議相關模塊怎么配置”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“Nginx中的HTTP協議相關模塊怎么配置”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。