One Level Up Top Level

src/http/ngx_http.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  14. static ngx_int_t ngx_http_init_phases(ngx_conf_t *cf,
  15.     ngx_http_core_main_conf_t *cmcf);
  16. static ngx_int_t ngx_http_init_headers_in_hash(ngx_conf_t *cf,
  17.     ngx_http_core_main_conf_t *cmcf);
  18. static ngx_int_t ngx_http_init_phase_handlers(ngx_conf_t *cf,
  19.     ngx_http_core_main_conf_t *cmcf);

  21. static ngx_int_t ngx_http_add_addresses(ngx_conf_t *cf,
  22.     ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port,
  23.     ngx_http_listen_opt_t *lsopt);
  24. static ngx_int_t ngx_http_add_address(ngx_conf_t *cf,
  25.     ngx_http_core_srv_conf_t *cscf, ngx_http_conf_port_t *port,
  26.     ngx_http_listen_opt_t *lsopt);
  27. static ngx_int_t ngx_http_add_server(ngx_conf_t *cf,
  28.     ngx_http_core_srv_conf_t *cscf, ngx_http_conf_addr_t *addr);

  30. static char *ngx_http_merge_servers(ngx_conf_t *cf,
  31.     ngx_http_core_main_conf_t *cmcf, ngx_http_module_t *module,
  32.     ngx_uint_t ctx_index);
  33. static char *ngx_http_merge_locations(ngx_conf_t *cf,
  34.     ngx_queue_t *locations, void **loc_conf, ngx_http_module_t *module,
  35.     ngx_uint_t ctx_index);
  36. static ngx_int_t ngx_http_init_locations(ngx_conf_t *cf,
  37.     ngx_http_core_srv_conf_t *cscf, ngx_http_core_loc_conf_t *pclcf);
  38. static ngx_int_t ngx_http_init_static_location_trees(ngx_conf_t *cf,
  39.     ngx_http_core_loc_conf_t *pclcf);
  40. static ngx_int_t ngx_http_escape_location_name(ngx_conf_t *cf,
  41.     ngx_http_core_loc_conf_t *clcf);
  42. static ngx_int_t ngx_http_cmp_locations(const ngx_queue_t *one,
  43.     const ngx_queue_t *two);
  44. static ngx_int_t ngx_http_join_exact_locations(ngx_conf_t *cf,
  45.     ngx_queue_t *locations);
  46. static void ngx_http_create_locations_list(ngx_queue_t *locations,
  47.     ngx_queue_t *q);
  48. static ngx_http_location_tree_node_t *
  49.     ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations,
  50.     size_t prefix);

  52. static ngx_int_t ngx_http_optimize_servers(ngx_conf_t *cf,
  53.     ngx_http_core_main_conf_t *cmcf, ngx_array_t *ports);
  54. static ngx_int_t ngx_http_server_names(ngx_conf_t *cf,
  55.     ngx_http_core_main_conf_t *cmcf, ngx_http_conf_addr_t *addr);
  56. static ngx_int_t ngx_http_cmp_conf_addrs(const void *one, const void *two);
  57. static int ngx_libc_cdecl ngx_http_cmp_dns_wildcards(const void *one,
  58.     const void *two);

  60. static ngx_int_t ngx_http_init_listening(ngx_conf_t *cf,
  61.     ngx_http_conf_port_t *port);
  62. static ngx_listening_t *ngx_http_add_listening(ngx_conf_t *cf,
  63.     ngx_http_conf_addr_t *addr);
  64. static ngx_int_t ngx_http_add_addrs(ngx_conf_t *cf, ngx_http_port_t *hport,
  65.     ngx_http_conf_addr_t *addr);
  66. #if (NGX_HAVE_INET6)
  67. static ngx_int_t ngx_http_add_addrs6(ngx_conf_t *cf, ngx_http_port_t *hport,
  68.     ngx_http_conf_addr_t *addr);
  69. #endif

  71. ‌ngx_uint_t   ngx_http_max_module;


  74. ‌ngx_http_output_header_filter_pt  ngx_http_top_header_filter;
  75. ‌ngx_http_output_header_filter_pt  ngx_http_top_early_hints_filter;
  76. ‌ngx_http_output_body_filter_pt    ngx_http_top_body_filter;
  77. ‌ngx_http_request_body_filter_pt   ngx_http_top_request_body_filter;


  80. ‌ngx_str_t  ngx_http_html_default_types[] = {
  81.     ngx_string("text/html"),
  82.     ngx_null_string
  83. };


  86. ‌static ngx_command_t  ngx_http_commands[] = {

  88.     { ngx_string("http"),
  89.       NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
  90.       ngx_http_block,
  91.       0,
  92.       0,
  93.       NULL },

  95.       ngx_null_command
  96. };


  99. ‌static ngx_core_module_t  ngx_http_module_ctx = {
  100.     ngx_string("http"),
  101.     NULL,
  102.     NULL
  103. };


  106. ‌ngx_module_t  ngx_http_module = {
  107.     NGX_MODULE_V1,
  108.     &ngx_http_module_ctx,                  /* module context */
  109.     ngx_http_commands,                     /* module directives */
  110.     NGX_CORE_MODULE,                       /* module type */
  111.     NULL,                                  /* init master */
  112.     NULL,                                  /* init module */
  113.     NULL,                                  /* init process */
  114.     NULL,                                  /* init thread */
  115.     NULL,                                  /* exit thread */
  116.     NULL,                                  /* exit process */
  117.     NULL,                                  /* exit master */
  118.     NGX_MODULE_V1_PADDING
  119. };


  122. static char *
  123. ‌ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  124. {
  125.     char                        *rv;
  126.     ngx_uint_t                   mi, m, s;
  127.     ngx_conf_t                   pcf;
  128.     ngx_http_module_t           *module;
  129.     ngx_http_conf_ctx_t         *ctx;
  130.     ngx_http_core_loc_conf_t    *clcf;
  131.     ngx_http_core_srv_conf_t   **cscfp;
  132.     ngx_http_core_main_conf_t   *cmcf;

  134.     if (*(ngx_http_conf_ctx_t **) conf) {
  135.         return "is duplicate";
  136.     }

  138.     /* the main http context */

  140.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  141.     if (ctx == NULL) {
  142.         return NGX_CONF_ERROR;
  143.     }

  145.     *(ngx_http_conf_ctx_t **) conf = ctx;


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

  150.     ngx_http_max_module = ngx_count_modules(cf->cycle, NGX_HTTP_MODULE);


  153.     /* the http main_conf context, it is the same in the all http contexts */

  155.     ctx->main_conf = ngx_pcalloc(cf->pool,
  156.                                  sizeof(void *) * ngx_http_max_module);
  157.     if (ctx->main_conf == NULL) {
  158.         return NGX_CONF_ERROR;
  159.     }


  162.     /*
  163.      * the http null srv_conf context, it is used to merge
  164.      * the server{}s' srv_conf's
  165.      */

  167.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  168.     if (ctx->srv_conf == NULL) {
  169.         return NGX_CONF_ERROR;
  170.     }


  173.     /*
  174.      * the http null loc_conf context, it is used to merge
  175.      * the server{}s' loc_conf's
  176.      */

  178.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  179.     if (ctx->loc_conf == NULL) {
  180.         return NGX_CONF_ERROR;
  181.     }


  184.     /*
  185.      * create the main_conf's, the null srv_conf's, and the null loc_conf's
  186.      * of the all http modules
  187.      */

  189.     for (m = 0; cf->cycle->modules[m]; m++) {
  190.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  191.             continue;
  192.         }

  194.         module = cf->cycle->modules[m]->ctx;
  195.         mi = cf->cycle->modules[m]->ctx_index;

  197.         if (module->create_main_conf) {
  198.             ctx->main_conf[mi] = module->create_main_conf(cf);
  199.             if (ctx->main_conf[mi] == NULL) {
  200.                 return NGX_CONF_ERROR;
  201.             }
  202.         }

  204.         if (module->create_srv_conf) {
  205.             ctx->srv_conf[mi] = module->create_srv_conf(cf);
  206.             if (ctx->srv_conf[mi] == NULL) {
  207.                 return NGX_CONF_ERROR;
  208.             }
  209.         }

  211.         if (module->create_loc_conf) {
  212.             ctx->loc_conf[mi] = module->create_loc_conf(cf);
  213.             if (ctx->loc_conf[mi] == NULL) {
  214.                 return NGX_CONF_ERROR;
  215.             }
  216.         }
  217.     }

  219.     pcf = *cf;
  220.     cf->ctx = ctx;

  222.     for (m = 0; cf->cycle->modules[m]; m++) {
  223.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  224.             continue;
  225.         }

  227.         module = cf->cycle->modules[m]->ctx;

  229.         if (module->preconfiguration) {
  230.             if (module->preconfiguration(cf) != NGX_OK) {
  231.                 return NGX_CONF_ERROR;
  232.             }
  233.         }
  234.     }

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

  238.     cf->module_type = NGX_HTTP_MODULE;
  239.     cf->cmd_type = NGX_HTTP_MAIN_CONF;
  240.     rv = ngx_conf_parse(cf, NULL);

  242.     if (rv != NGX_CONF_OK) {
  243.         goto failed;
  244.     }

  246.     /*
  247.      * init http{} main_conf's, merge the server{}s' srv_conf's
  248.      * and its location{}s' loc_conf's
  249.      */

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

  254.     for (m = 0; cf->cycle->modules[m]; m++) {
  255.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  256.             continue;
  257.         }

  259.         module = cf->cycle->modules[m]->ctx;
  260.         mi = cf->cycle->modules[m]->ctx_index;

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

  264.         if (module->init_main_conf) {
  265.             rv = module->init_main_conf(cf, ctx->main_conf[mi]);
  266.             if (rv != NGX_CONF_OK) {
  267.                 goto failed;
  268.             }
  269.         }

  271.         rv = ngx_http_merge_servers(cf, cmcf, module, mi);
  272.         if (rv != NGX_CONF_OK) {
  273.             goto failed;
  274.         }
  275.     }


  278.     /* create location trees */

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

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

  284.         if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) {
  285.             return NGX_CONF_ERROR;
  286.         }

  288.         if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
  289.             return NGX_CONF_ERROR;
  290.         }
  291.     }


  294.     if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
  295.         return NGX_CONF_ERROR;
  296.     }

  298.     if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) {
  299.         return NGX_CONF_ERROR;
  300.     }


  303.     for (m = 0; cf->cycle->modules[m]; m++) {
  304.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  305.             continue;
  306.         }

  308.         module = cf->cycle->modules[m]->ctx;

  310.         if (module->postconfiguration) {
  311.             if (module->postconfiguration(cf) != NGX_OK) {
  312.                 return NGX_CONF_ERROR;
  313.             }
  314.         }
  315.     }

  317.     if (ngx_http_variables_init_vars(cf) != NGX_OK) {
  318.         return NGX_CONF_ERROR;
  319.     }

  321.     /*
  322.      * http{}'s cf->ctx was needed while the configuration merging
  323.      * and in postconfiguration process
  324.      */

  326.     *cf = pcf;


  329.     if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) {
  330.         return NGX_CONF_ERROR;
  331.     }


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

  336.     if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
  337.         return NGX_CONF_ERROR;
  338.     }

  340.     return NGX_CONF_OK;

  342. failed:

  344.     *cf = pcf;

  346.     return rv;
  347. }


  350. static ngx_int_t
  351. ‌ngx_http_init_phases(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
  352. {
  353.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_POST_READ_PHASE].handlers,
  354.                        cf->pool, 1, sizeof(ngx_http_handler_pt))
  355.         != NGX_OK)
  356.     {
  357.         return NGX_ERROR;
  358.     }

  360.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_SERVER_REWRITE_PHASE].handlers,
  361.                        cf->pool, 1, sizeof(ngx_http_handler_pt))
  362.         != NGX_OK)
  363.     {
  364.         return NGX_ERROR;
  365.     }

  367.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers,
  368.                        cf->pool, 1, sizeof(ngx_http_handler_pt))
  369.         != NGX_OK)
  370.     {
  371.         return NGX_ERROR;
  372.     }

  374.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers,
  375.                        cf->pool, 1, sizeof(ngx_http_handler_pt))
  376.         != NGX_OK)
  377.     {
  378.         return NGX_ERROR;
  379.     }

  381.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers,
  382.                        cf->pool, 2, sizeof(ngx_http_handler_pt))
  383.         != NGX_OK)
  384.     {
  385.         return NGX_ERROR;
  386.     }

  388.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_PRECONTENT_PHASE].handlers,
  389.                        cf->pool, 2, sizeof(ngx_http_handler_pt))
  390.         != NGX_OK)
  391.     {
  392.         return NGX_ERROR;
  393.     }

  395.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers,
  396.                        cf->pool, 4, sizeof(ngx_http_handler_pt))
  397.         != NGX_OK)
  398.     {
  399.         return NGX_ERROR;
  400.     }

  402.     if (ngx_array_init(&cmcf->phases[NGX_HTTP_LOG_PHASE].handlers,
  403.                        cf->pool, 1, sizeof(ngx_http_handler_pt))
  404.         != NGX_OK)
  405.     {
  406.         return NGX_ERROR;
  407.     }

  409.     return NGX_OK;
  410. }


  413. static ngx_int_t
  414. ‌ngx_http_init_headers_in_hash(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
  415. {
  416.     ngx_array_t         headers_in;
  417.     ngx_hash_key_t     *hk;
  418.     ngx_hash_init_t     hash;
  419.     ngx_http_header_t  *header;

  421.     if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
  422.         != NGX_OK)
  423.     {
  424.         return NGX_ERROR;
  425.     }

  427.     for (header = ngx_http_headers_in; header->name.len; header++) {
  428.         hk = ngx_array_push(&headers_in);
  429.         if (hk == NULL) {
  430.             return NGX_ERROR;
  431.         }

  433.         hk->key = header->name;
  434.         hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
  435.         hk->value = header;
  436.     }

  438.     hash.hash = &cmcf->headers_in_hash;
  439.     hash.key = ngx_hash_key_lc;
  440.     hash.max_size = 512;
  441.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  442.     hash.name = "headers_in_hash";
  443.     hash.pool = cf->pool;
  444.     hash.temp_pool = NULL;

  446.     if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
  447.         return NGX_ERROR;
  448.     }

  450.     return NGX_OK;
  451. }


  454. static ngx_int_t
  455. ‌ngx_http_init_phase_handlers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
  456. {
  457.     ngx_int_t                   j;
  458.     ngx_uint_t                  i, n;
  459.     ngx_uint_t                  find_config_index, use_rewrite, use_access;
  460.     ngx_http_handler_pt        *h;
  461.     ngx_http_phase_handler_t   *ph;
  462.     ngx_http_phase_handler_pt   checker;

  464.     cmcf->phase_engine.server_rewrite_index = (ngx_uint_t) -1;
  465.     cmcf->phase_engine.location_rewrite_index = (ngx_uint_t) -1;
  466.     find_config_index = 0;
  467.     use_rewrite = cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers.nelts ? 1 : 0;
  468.     use_access = cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers.nelts ? 1 : 0;

  470.     n = 1                  /* find config phase */
  471.         + use_rewrite      /* post rewrite phase */
  472.         + use_access;      /* post access phase */

  474.     for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) {
  475.         n += cmcf->phases[i].handlers.nelts;
  476.     }

  478.     ph = ngx_pcalloc(cf->pool,
  479.                      n * sizeof(ngx_http_phase_handler_t) + sizeof(void *));
  480.     if (ph == NULL) {
  481.         return NGX_ERROR;
  482.     }

  484.     cmcf->phase_engine.handlers = ph;
  485.     n = 0;

  487.     for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) {
  488.         h = cmcf->phases[i].handlers.elts;

  490.         switch (i) {

  492.         case NGX_HTTP_SERVER_REWRITE_PHASE:
  493.             if (cmcf->phase_engine.server_rewrite_index == (ngx_uint_t) -1) {
  494.                 cmcf->phase_engine.server_rewrite_index = n;
  495.             }
  496.             checker = ngx_http_core_rewrite_phase;

  498.             break;

  500.         case NGX_HTTP_FIND_CONFIG_PHASE:
  501.             find_config_index = n;

  503.             ph->checker = ngx_http_core_find_config_phase;
  504.             n++;
  505.             ph++;

  507.             continue;

  509.         case NGX_HTTP_REWRITE_PHASE:
  510.             if (cmcf->phase_engine.location_rewrite_index == (ngx_uint_t) -1) {
  511.                 cmcf->phase_engine.location_rewrite_index = n;
  512.             }
  513.             checker = ngx_http_core_rewrite_phase;

  515.             break;

  517.         case NGX_HTTP_POST_REWRITE_PHASE:
  518.             if (use_rewrite) {
  519.                 ph->checker = ngx_http_core_post_rewrite_phase;
  520.                 ph->next = find_config_index;
  521.                 n++;
  522.                 ph++;
  523.             }

  525.             continue;

  527.         case NGX_HTTP_ACCESS_PHASE:
  528.             checker = ngx_http_core_access_phase;
  529.             n++;
  530.             break;

  532.         case NGX_HTTP_POST_ACCESS_PHASE:
  533.             if (use_access) {
  534.                 ph->checker = ngx_http_core_post_access_phase;
  535.                 ph->next = n;
  536.                 ph++;
  537.             }

  539.             continue;

  541.         case NGX_HTTP_CONTENT_PHASE:
  542.             checker = ngx_http_core_content_phase;
  543.             break;

  545.         default:
  546.             checker = ngx_http_core_generic_phase;
  547.         }

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

  551.         for (j = cmcf->phases[i].handlers.nelts - 1; j >= 0; j--) {
  552.             ph->checker = checker;
  553.             ph->handler = h[j];
  554.             ph->next = n;
  555.             ph++;
  556.         }
  557.     }

  559.     return NGX_OK;
  560. }


  563. static char *
  564. ‌ngx_http_merge_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
  565.     ngx_http_module_t *module, ngx_uint_t ctx_index)
  566. {
  567.     char                        *rv;
  568.     ngx_uint_t                   s;
  569.     ngx_http_conf_ctx_t         *ctx, saved;
  570.     ngx_http_core_loc_conf_t    *clcf;
  571.     ngx_http_core_srv_conf_t   **cscfp;

  573.     cscfp = cmcf->servers.elts;
  574.     ctx = (ngx_http_conf_ctx_t *) cf->ctx;
  575.     saved = *ctx;
  576.     rv = NGX_CONF_OK;

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

  580.         /* merge the server{}s' srv_conf's */

  582.         ctx->srv_conf = cscfp[s]->ctx->srv_conf;

  584.         if (module->merge_srv_conf) {
  585.             rv = module->merge_srv_conf(cf, saved.srv_conf[ctx_index],
  586.                                         cscfp[s]->ctx->srv_conf[ctx_index]);
  587.             if (rv != NGX_CONF_OK) {
  588.                 goto failed;
  589.             }
  590.         }

  592.         if (module->merge_loc_conf) {

  594.             /* merge the server{}'s loc_conf */

  596.             ctx->loc_conf = cscfp[s]->ctx->loc_conf;

  598.             rv = module->merge_loc_conf(cf, saved.loc_conf[ctx_index],
  599.                                         cscfp[s]->ctx->loc_conf[ctx_index]);
  600.             if (rv != NGX_CONF_OK) {
  601.                 goto failed;
  602.             }

  604.             /* merge the locations{}' loc_conf's */

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

  608.             rv = ngx_http_merge_locations(cf, clcf->locations,
  609.                                           cscfp[s]->ctx->loc_conf,
  610.                                           module, ctx_index);
  611.             if (rv != NGX_CONF_OK) {
  612.                 goto failed;
  613.             }
  614.         }
  615.     }

  617. failed:

  619.     *ctx = saved;

  621.     return rv;
  622. }


  625. static char *
  626. ‌ngx_http_merge_locations(ngx_conf_t *cf, ngx_queue_t *locations,
  627.     void **loc_conf, ngx_http_module_t *module, ngx_uint_t ctx_index)
  628. {
  629.     char                       *rv;
  630.     ngx_queue_t                *q;
  631.     ngx_http_conf_ctx_t        *ctx, saved;
  632.     ngx_http_core_loc_conf_t   *clcf;
  633.     ngx_http_location_queue_t  *lq;

  635.     if (locations == NULL) {
  636.         return NGX_CONF_OK;
  637.     }

  639.     ctx = (ngx_http_conf_ctx_t *) cf->ctx;
  640.     saved = *ctx;

  642.     for (q = ngx_queue_head(locations);
  643.          q != ngx_queue_sentinel(locations);
  644.          q = ngx_queue_next(q))
  645.     {
  646.         lq = (ngx_http_location_queue_t *) q;

  648.         clcf = lq->exact ? lq->exact : lq->inclusive;
  649.         ctx->loc_conf = clcf->loc_conf;

  651.         rv = module->merge_loc_conf(cf, loc_conf[ctx_index],
  652.                                     clcf->loc_conf[ctx_index]);
  653.         if (rv != NGX_CONF_OK) {
  654.             return rv;
  655.         }

  657.         rv = ngx_http_merge_locations(cf, clcf->locations, clcf->loc_conf,
  658.                                       module, ctx_index);
  659.         if (rv != NGX_CONF_OK) {
  660.             return rv;
  661.         }
  662.     }

  664.     *ctx = saved;

  666.     return NGX_CONF_OK;
  667. }


  670. static ngx_int_t
  671. ‌ngx_http_init_locations(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
  672.     ngx_http_core_loc_conf_t *pclcf)
  673. {
  674.     ngx_uint_t                   n, p;
  675.     ngx_queue_t                 *q, *locations, *named, *predicate, tail;
  676.     ngx_http_core_loc_conf_t    *clcf;
  677.     ngx_http_location_queue_t   *lq;
  678.     ngx_http_core_loc_conf_t   **clcfp;
  679. #if (NGX_PCRE)
  680.     ngx_uint_t                   r;
  681.     ngx_queue_t                 *regex;
  682. #endif

  684.     locations = pclcf->locations;

  686.     if (locations == NULL) {
  687.         return NGX_OK;
  688.     }

  690.     ngx_queue_sort(locations, ngx_http_cmp_locations);

  692.     named = NULL;
  693.     n = 0;
  694. #if (NGX_PCRE)
  695.     regex = NULL;
  696.     r = 0;
  697. #endif
  698.     predicate = NULL;
  699.     p = 0;

  701.     for (q = ngx_queue_head(locations);
  702.          q != ngx_queue_sentinel(locations);
  703.          q = ngx_queue_next(q))
  704.     {
  705.         lq = (ngx_http_location_queue_t *) q;

  707.         clcf = lq->exact ? lq->exact : lq->inclusive;

  709.         if (ngx_http_init_locations(cf, NULL, clcf) != NGX_OK) {
  710.             return NGX_ERROR;
  711.         }

  713. #if (NGX_PCRE)

  715.         if (clcf->regex) {
  716.             r++;

  718.             if (regex == NULL) {
  719.                 regex = q;
  720.             }

  722.             continue;
  723.         }

  725. #endif

  727.         if (clcf->predicate) {
  728.             p++;

  730.             if (predicate == NULL) {
  731.                 predicate = q;
  732.             }

  734.             continue;
  735.         }

  737.         if (clcf->named) {
  738.             n++;

  740.             if (named == NULL) {
  741.                 named = q;
  742.             }

  744.             continue;
  745.         }

  747.         if (clcf->noname) {
  748.             break;
  749.         }
  750.     }

  752.     if (q != ngx_queue_sentinel(locations)) {
  753.         ngx_queue_split(locations, q, &tail);
  754.     }

  756.     if (named) {
  757.         clcfp = ngx_palloc(cf->pool,
  758.                            (n + 1) * sizeof(ngx_http_core_loc_conf_t *));
  759.         if (clcfp == NULL) {
  760.             return NGX_ERROR;
  761.         }

  763.         cscf->named_locations = clcfp;

  765.         for (q = named;
  766.              q != ngx_queue_sentinel(locations);
  767.              q = ngx_queue_next(q))
  768.         {
  769.             lq = (ngx_http_location_queue_t *) q;

  771.             *(clcfp++) = lq->exact;
  772.         }

  774.         *clcfp = NULL;

  776.         ngx_queue_split(locations, named, &tail);
  777.     }

  779.     if (predicate) {
  780.         clcfp = ngx_palloc(cf->pool,
  781.                            (p + 1) * sizeof(ngx_http_core_loc_conf_t *));
  782.         if (clcfp == NULL) {
  783.             return NGX_ERROR;
  784.         }

  786.         pclcf->predicate_locations = clcfp;

  788.         for (q = predicate;
  789.              q != ngx_queue_sentinel(locations);
  790.              q = ngx_queue_next(q))
  791.         {
  792.             lq = (ngx_http_location_queue_t *) q;

  794.             *(clcfp++) = lq->exact;
  795.         }

  797.         *clcfp = NULL;

  799.         ngx_queue_split(locations, predicate, &tail);
  800.     }

  802. #if (NGX_PCRE)

  804.     if (regex) {

  806.         clcfp = ngx_palloc(cf->pool,
  807.                            (r + 1) * sizeof(ngx_http_core_loc_conf_t *));
  808.         if (clcfp == NULL) {
  809.             return NGX_ERROR;
  810.         }

  812.         pclcf->regex_locations = clcfp;

  814.         for (q = regex;
  815.              q != ngx_queue_sentinel(locations);
  816.              q = ngx_queue_next(q))
  817.         {
  818.             lq = (ngx_http_location_queue_t *) q;

  820.             *(clcfp++) = lq->exact;
  821.         }

  823.         *clcfp = NULL;

  825.         ngx_queue_split(locations, regex, &tail);
  826.     }

  828. #endif

  830.     return NGX_OK;
  831. }


  834. static ngx_int_t
  835. ‌ngx_http_init_static_location_trees(ngx_conf_t *cf,
  836.     ngx_http_core_loc_conf_t *pclcf)
  837. {
  838.     ngx_queue_t                *q, *locations;
  839.     ngx_http_core_loc_conf_t   *clcf, **clcfp;
  840.     ngx_http_location_queue_t  *lq;

  842.     if (pclcf->predicate_locations) {
  843.         for (clcfp = pclcf->predicate_locations; *clcfp; clcfp++) {
  844.             if (ngx_http_init_static_location_trees(cf, *clcfp) != NGX_OK) {
  845.                 return NGX_ERROR;
  846.             }
  847.         }
  848.     }

  850.     locations = pclcf->locations;

  852.     if (locations == NULL) {
  853.         return NGX_OK;
  854.     }

  856.     if (ngx_queue_empty(locations)) {
  857.         return NGX_OK;
  858.     }

  860.     for (q = ngx_queue_head(locations);
  861.          q != ngx_queue_sentinel(locations);
  862.          q = ngx_queue_next(q))
  863.     {
  864.         lq = (ngx_http_location_queue_t *) q;

  866.         clcf = lq->exact ? lq->exact : lq->inclusive;

  868.         if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
  869.             return NGX_ERROR;
  870.         }
  871.     }

  873.     if (ngx_http_join_exact_locations(cf, locations) != NGX_OK) {
  874.         return NGX_ERROR;
  875.     }

  877.     ngx_http_create_locations_list(locations, ngx_queue_head(locations));

  879.     pclcf->static_locations = ngx_http_create_locations_tree(cf, locations, 0);
  880.     if (pclcf->static_locations == NULL) {
  881.         return NGX_ERROR;
  882.     }

  884.     return NGX_OK;
  885. }


  888. ngx_int_t
  889. ‌ngx_http_add_location(ngx_conf_t *cf, ngx_queue_t **locations,
  890.     ngx_http_core_loc_conf_t *clcf)
  891. {
  892.     ngx_http_location_queue_t  *lq;

  894.     if (*locations == NULL) {
  895.         *locations = ngx_palloc(cf->temp_pool,
  896.                                 sizeof(ngx_http_location_queue_t));
  897.         if (*locations == NULL) {
  898.             return NGX_ERROR;
  899.         }

  901.         ngx_queue_init(*locations);
  902.     }

  904.     lq = ngx_palloc(cf->temp_pool, sizeof(ngx_http_location_queue_t));
  905.     if (lq == NULL) {
  906.         return NGX_ERROR;
  907.     }

  909.     if (clcf->exact_match
  910. #if (NGX_PCRE)
  911.         || clcf->regex
  912. #endif
  913.         || clcf->predicate || clcf->named || clcf->noname)
  914.     {
  915.         lq->exact = clcf;
  916.         lq->inclusive = NULL;

  918.     } else {
  919.         lq->exact = NULL;
  920.         lq->inclusive = clcf;
  921.     }

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

  927.     ngx_queue_init(&lq->list);

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

  931.     if (ngx_http_escape_location_name(cf, clcf) != NGX_OK) {
  932.         return NGX_ERROR;
  933.     }

  935.     return NGX_OK;
  936. }


  939. static ngx_int_t
  940. ‌ngx_http_escape_location_name(ngx_conf_t *cf, ngx_http_core_loc_conf_t *clcf)
  941. {
  942.     u_char     *p;
  943.     size_t      len;
  944.     uintptr_t   escape;

  946.     escape = 2 * ngx_escape_uri(NULL, clcf->name.data, clcf->name.len,
  947.                                 NGX_ESCAPE_URI);

  949.     if (escape) {
  950.         len = clcf->name.len + escape;

  952.         p = ngx_pnalloc(cf->pool, len);
  953.         if (p == NULL) {
  954.             return NGX_ERROR;
  955.         }

  957.         clcf->escaped_name.len = len;
  958.         clcf->escaped_name.data = p;

  960.         ngx_escape_uri(p, clcf->name.data, clcf->name.len, NGX_ESCAPE_URI);

  962.     } else {
  963.         clcf->escaped_name = clcf->name;
  964.     }

  966.     return NGX_OK;
  967. }


  970. static ngx_int_t
  971. ‌ngx_http_cmp_locations(const ngx_queue_t *one, const ngx_queue_t *two)
  972. {
  973.     ngx_int_t                   rc;
  974.     ngx_http_core_loc_conf_t   *first, *second;
  975.     ngx_http_location_queue_t  *lq1, *lq2;

  977.     lq1 = (ngx_http_location_queue_t *) one;
  978.     lq2 = (ngx_http_location_queue_t *) two;

  980.     first = lq1->exact ? lq1->exact : lq1->inclusive;
  981.     second = lq2->exact ? lq2->exact : lq2->inclusive;

  983.     if (first->noname && !second->noname) {
  984.         /* shift no named locations to the end */
  985.         return 1;
  986.     }

  988.     if (!first->noname && second->noname) {
  989.         /* shift no named locations to the end */
  990.         return -1;
  991.     }

  993.     if (first->noname || second->noname) {
  994.         /* do not sort no named locations */
  995.         return 0;
  996.     }

  998.     if (first->named && !second->named) {
  999.         /* shift named locations to the end */
  1000.         return 1;
  1001.     }

  1003.     if (!first->named && second->named) {
  1004.         /* shift named locations to the end */
  1005.         return -1;
  1006.     }

  1008.     if (first->named && second->named) {
  1009.         return ngx_strcmp(first->name.data, second->name.data);
  1010.     }

  1012.     if (first->predicate && !second->predicate) {
  1013.         /* shift predicate locations to the end */
  1014.         return 1;
  1015.     }

  1017.     if (!first->predicate && second->predicate) {
  1018.         /* shift predicate locations to the end */
  1019.         return -1;
  1020.     }

  1022.     if (first->predicate || second->predicate) {
  1023.         /* do not sort the predicate locations */
  1024.         return 0;
  1025.     }

  1027. #if (NGX_PCRE)

  1029.     if (first->regex && !second->regex) {
  1030.         /* shift the regex matches to the end */
  1031.         return 1;
  1032.     }

  1034.     if (!first->regex && second->regex) {
  1035.         /* shift the regex matches to the end */
  1036.         return -1;
  1037.     }

  1039.     if (first->regex || second->regex) {
  1040.         /* do not sort the regex matches */
  1041.         return 0;
  1042.     }

  1044. #endif

  1046.     rc = ngx_filename_cmp(first->name.data, second->name.data,
  1047.                           ngx_min(first->name.len, second->name.len) + 1);

  1049.     if (rc == 0 && !first->exact_match && second->exact_match) {
  1050.         /* an exact match must be before the same inclusive one */
  1051.         return 1;
  1052.     }

  1054.     return rc;
  1055. }


  1058. static ngx_int_t
  1059. ‌ngx_http_join_exact_locations(ngx_conf_t *cf, ngx_queue_t *locations)
  1060. {
  1061.     ngx_queue_t                *q, *x;
  1062.     ngx_http_location_queue_t  *lq, *lx;

  1064.     q = ngx_queue_head(locations);

  1066.     while (q != ngx_queue_last(locations)) {

  1068.         x = ngx_queue_next(q);

  1070.         lq = (ngx_http_location_queue_t *) q;
  1071.         lx = (ngx_http_location_queue_t *) x;

  1073.         if (lq->name->len == lx->name->len
  1074.             && ngx_filename_cmp(lq->name->data, lx->name->data, lx->name->len)
  1075.                == 0)
  1076.         {
  1077.             if ((lq->exact && lx->exact) || (lq->inclusive && lx->inclusive)) {
  1078.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1079.                               "duplicate location \"%V\" in %s:%ui",
  1080.                               lx->name, lx->file_name, lx->line);

  1082.                 return NGX_ERROR;
  1083.             }

  1085.             lq->inclusive = lx->inclusive;

  1087.             ngx_queue_remove(x);

  1089.             continue;
  1090.         }

  1092.         q = ngx_queue_next(q);
  1093.     }

  1095.     return NGX_OK;
  1096. }


  1099. static void
  1100. ‌ngx_http_create_locations_list(ngx_queue_t *locations, ngx_queue_t *q)
  1101. {
  1102.     u_char                     *name;
  1103.     size_t                      len;
  1104.     ngx_queue_t                *x, tail;
  1105.     ngx_http_location_queue_t  *lq, *lx;

  1107.     if (q == ngx_queue_last(locations)) {
  1108.         return;
  1109.     }

  1111.     lq = (ngx_http_location_queue_t *) q;

  1113.     if (lq->inclusive == NULL) {
  1114.         ngx_http_create_locations_list(locations, ngx_queue_next(q));
  1115.         return;
  1116.     }

  1118.     len = lq->name->len;
  1119.     name = lq->name->data;

  1121.     for (x = ngx_queue_next(q);
  1122.          x != ngx_queue_sentinel(locations);
  1123.          x = ngx_queue_next(x))
  1124.     {
  1125.         lx = (ngx_http_location_queue_t *) x;

  1127.         if (len > lx->name->len
  1128.             || ngx_filename_cmp(name, lx->name->data, len) != 0)
  1129.         {
  1130.             break;
  1131.         }
  1132.     }

  1134.     q = ngx_queue_next(q);

  1136.     if (q == x) {
  1137.         ngx_http_create_locations_list(locations, x);
  1138.         return;
  1139.     }

  1141.     ngx_queue_split(locations, q, &tail);
  1142.     ngx_queue_add(&lq->list, &tail);

  1144.     if (x == ngx_queue_sentinel(locations)) {
  1145.         ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
  1146.         return;
  1147.     }

  1149.     ngx_queue_split(&lq->list, x, &tail);
  1150.     ngx_queue_add(locations, &tail);

  1152.     ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));

  1154.     ngx_http_create_locations_list(locations, x);
  1155. }


  1158. /*
  1159. * to keep cache locality for left leaf nodes, allocate nodes in following
  1160. * order: node, left subtree, right subtree, inclusive subtree
  1161. */

  1163. static ngx_http_location_tree_node_t *
  1164. ‌ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations,
  1165.     size_t prefix)
  1166. {
  1167.     size_t                          len;
  1168.     ngx_queue_t                    *q, tail;
  1169.     ngx_http_location_queue_t      *lq;
  1170.     ngx_http_location_tree_node_t  *node;

  1172.     q = ngx_queue_middle(locations);

  1174.     lq = (ngx_http_location_queue_t *) q;
  1175.     len = lq->name->len - prefix;

  1177.     node = ngx_palloc(cf->pool,
  1178.                       offsetof(ngx_http_location_tree_node_t, name) + len);
  1179.     if (node == NULL) {
  1180.         return NULL;
  1181.     }

  1183.     node->left = NULL;
  1184.     node->right = NULL;
  1185.     node->tree = NULL;
  1186.     node->exact = lq->exact;
  1187.     node->inclusive = lq->inclusive;

  1189.     node->auto_redirect = (u_char) ((lq->exact && lq->exact->auto_redirect)
  1190.                            || (lq->inclusive && lq->inclusive->auto_redirect));

  1192.     node->len = (u_short) len;
  1193.     ngx_memcpy(node->name, &lq->name->data[prefix], len);

  1195.     ngx_queue_split(locations, q, &tail);

  1197.     if (ngx_queue_empty(locations)) {
  1198.         /*
  1199.          * ngx_queue_split() insures that if left part is empty,
  1200.          * then right one is empty too
  1201.          */
  1202.         goto inclusive;
  1203.     }

  1205.     node->left = ngx_http_create_locations_tree(cf, locations, prefix);
  1206.     if (node->left == NULL) {
  1207.         return NULL;
  1208.     }

  1210.     ngx_queue_remove(q);

  1212.     if (ngx_queue_empty(&tail)) {
  1213.         goto inclusive;
  1214.     }

  1216.     node->right = ngx_http_create_locations_tree(cf, &tail, prefix);
  1217.     if (node->right == NULL) {
  1218.         return NULL;
  1219.     }

  1221. inclusive:

  1223.     if (ngx_queue_empty(&lq->list)) {
  1224.         return node;
  1225.     }

  1227.     node->tree = ngx_http_create_locations_tree(cf, &lq->list, prefix + len);
  1228.     if (node->tree == NULL) {
  1229.         return NULL;
  1230.     }

  1232.     return node;
  1233. }


  1236. ngx_int_t
  1237. ‌ngx_http_add_listen(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
  1238.     ngx_http_listen_opt_t *lsopt)
  1239. {
  1240.     in_port_t                   p;
  1241.     ngx_uint_t                  i;
  1242.     struct sockaddr            *sa;
  1243.     ngx_http_conf_port_t       *port;
  1244.     ngx_http_core_main_conf_t  *cmcf;

  1246.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  1248.     if (cmcf->ports == NULL) {
  1249.         cmcf->ports = ngx_array_create(cf->temp_pool, 2,
  1250.                                        sizeof(ngx_http_conf_port_t));
  1251.         if (cmcf->ports == NULL) {
  1252.             return NGX_ERROR;
  1253.         }
  1254.     }

  1256.     sa = lsopt->sockaddr;
  1257.     p = ngx_inet_get_port(sa);

  1259.     port = cmcf->ports->elts;
  1260.     for (i = 0; i < cmcf->ports->nelts; i++) {

  1262.         if (p != port[i].port
  1263.             || lsopt->type != port[i].type
  1264.             || sa->sa_family != port[i].family)
  1265.         {
  1266.             continue;
  1267.         }

  1269.         /* a port is already in the port list */

  1271.         return ngx_http_add_addresses(cf, cscf, &port[i], lsopt);
  1272.     }

  1274.     /* add a port to the port list */

  1276.     port = ngx_array_push(cmcf->ports);
  1277.     if (port == NULL) {
  1278.         return NGX_ERROR;
  1279.     }

  1281.     port->family = sa->sa_family;
  1282.     port->type = lsopt->type;
  1283.     port->port = p;
  1284.     port->addrs.elts = NULL;

  1286.     return ngx_http_add_address(cf, cscf, port, lsopt);
  1287. }


  1290. static ngx_int_t
  1291. ‌ngx_http_add_addresses(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
  1292.     ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
  1293. {
  1294.     ngx_uint_t             i, default_server, proxy_protocol,
  1295.                            protocols, protocols_prev;
  1296.     ngx_http_conf_addr_t  *addr;
  1297. #if (NGX_HTTP_SSL)
  1298.     ngx_uint_t             ssl;
  1299. #endif
  1300. #if (NGX_HTTP_V2)
  1301.     ngx_uint_t             http2;
  1302. #endif
  1303. #if (NGX_HTTP_V3)
  1304.     ngx_uint_t             quic;
  1305. #endif

  1307.     /*
  1308.      * we cannot compare whole sockaddr struct's as kernel
  1309.      * may fill some fields in inherited sockaddr struct's
  1310.      */

  1312.     addr = port->addrs.elts;

  1314.     for (i = 0; i < port->addrs.nelts; i++) {

  1316.         if (ngx_cmp_sockaddr(lsopt->sockaddr, lsopt->socklen,
  1317.                              addr[i].opt.sockaddr,
  1318.                              addr[i].opt.socklen, 0)
  1319.             != NGX_OK)
  1320.         {
  1321.             continue;
  1322.         }

  1324.         /* the address is already in the address list */

  1326.         if (ngx_http_add_server(cf, cscf, &addr[i]) != NGX_OK) {
  1327.             return NGX_ERROR;
  1328.         }

  1330.         /* preserve default_server bit during listen options overwriting */
  1331.         default_server = addr[i].opt.default_server;

  1333.         proxy_protocol = lsopt->proxy_protocol || addr[i].opt.proxy_protocol;
  1334.         protocols = lsopt->proxy_protocol;
  1335.         protocols_prev = addr[i].opt.proxy_protocol;

  1337. #if (NGX_HTTP_SSL)
  1338.         ssl = lsopt->ssl || addr[i].opt.ssl;
  1339.         protocols |= lsopt->ssl << 1;
  1340.         protocols_prev |= addr[i].opt.ssl << 1;
  1341. #endif
  1342. #if (NGX_HTTP_V2)
  1343.         http2 = lsopt->http2 || addr[i].opt.http2;
  1344.         protocols |= lsopt->http2 << 2;
  1345.         protocols_prev |= addr[i].opt.http2 << 2;
  1346. #endif
  1347. #if (NGX_HTTP_V3)
  1348.         quic = lsopt->quic || addr[i].opt.quic;
  1349. #endif

  1351.         if (lsopt->set) {

  1353.             if (addr[i].opt.set) {
  1354.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1355.                                    "duplicate listen options for %V",
  1356.                                    &addr[i].opt.addr_text);
  1357.                 return NGX_ERROR;
  1358.             }

  1360.             addr[i].opt = *lsopt;
  1361.         }

  1363.         /* check the duplicate "default" server for this address:port */

  1365.         if (lsopt->default_server) {

  1367.             if (default_server) {
  1368.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1369.                                    "a duplicate default server for %V",
  1370.                                    &addr[i].opt.addr_text);
  1371.                 return NGX_ERROR;
  1372.             }

  1374.             default_server = 1;
  1375.             addr[i].default_server = cscf;
  1376.         }

  1378.         /* check for conflicting protocol options */

  1380.         if ((protocols | protocols_prev) != protocols_prev) {

  1382.             /* options added */

  1384.             if ((addr[i].opt.set && !lsopt->set)
  1385.                 || addr[i].protocols_changed
  1386.                 || (protocols | protocols_prev) != protocols)
  1387.             {
  1388.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1389.                                    "protocol options redefined for %V",
  1390.                                    &addr[i].opt.addr_text);
  1391.             }

  1393.             addr[i].protocols = protocols_prev;
  1394.             addr[i].protocols_set = 1;
  1395.             addr[i].protocols_changed = 1;

  1397.         } else if ((protocols_prev | protocols) != protocols) {

  1399.             /* options removed */

  1401.             if (lsopt->set
  1402.                 || (addr[i].protocols_set && protocols != addr[i].protocols))
  1403.             {
  1404.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1405.                                    "protocol options redefined for %V",
  1406.                                    &addr[i].opt.addr_text);
  1407.             }

  1409.             addr[i].protocols = protocols;
  1410.             addr[i].protocols_set = 1;
  1411.             addr[i].protocols_changed = 1;

  1413.         } else {

  1415.             /* the same options */

  1417.             if ((lsopt->set && addr[i].protocols_changed)
  1418.                 || (addr[i].protocols_set && protocols != addr[i].protocols))
  1419.             {
  1420.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1421.                                    "protocol options redefined for %V",
  1422.                                    &addr[i].opt.addr_text);
  1423.             }

  1425.             addr[i].protocols = protocols;
  1426.             addr[i].protocols_set = 1;
  1427.         }

  1429.         addr[i].opt.default_server = default_server;
  1430.         addr[i].opt.proxy_protocol = proxy_protocol;
  1431. #if (NGX_HTTP_SSL)
  1432.         addr[i].opt.ssl = ssl;
  1433. #endif
  1434. #if (NGX_HTTP_V2)
  1435.         addr[i].opt.http2 = http2;
  1436. #endif
  1437. #if (NGX_HTTP_V3)
  1438.         addr[i].opt.quic = quic;
  1439. #endif

  1441.         return NGX_OK;
  1442.     }

  1444.     /* add the address to the addresses list that bound to this port */

  1446.     return ngx_http_add_address(cf, cscf, port, lsopt);
  1447. }


  1450. /*
  1451. * add the server address, the server names and the server core module
  1452. * configurations to the port list
  1453. */

  1455. static ngx_int_t
  1456. ‌ngx_http_add_address(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
  1457.     ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
  1458. {
  1459.     ngx_http_conf_addr_t  *addr;

  1461.     if (port->addrs.elts == NULL) {
  1462.         if (ngx_array_init(&port->addrs, cf->temp_pool, 4,
  1463.                            sizeof(ngx_http_conf_addr_t))
  1464.             != NGX_OK)
  1465.         {
  1466.             return NGX_ERROR;
  1467.         }
  1468.     }

  1470. #if (NGX_HTTP_V2 && NGX_HTTP_SSL                                              \
  1471.      && !defined TLSEXT_TYPE_application_layer_protocol_negotiation)

  1473.     if (lsopt->http2 && lsopt->ssl) {
  1474.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1475.                            "nginx was built with OpenSSL that lacks ALPN "
  1476.                            "support, HTTP/2 is not enabled for %V",
  1477.                            &lsopt->addr_text);
  1478.     }

  1480. #endif

  1482.     addr = ngx_array_push(&port->addrs);
  1483.     if (addr == NULL) {
  1484.         return NGX_ERROR;
  1485.     }

  1487.     addr->opt = *lsopt;
  1488.     addr->protocols = 0;
  1489.     addr->protocols_set = 0;
  1490.     addr->protocols_changed = 0;
  1491.     addr->hash.buckets = NULL;
  1492.     addr->hash.size = 0;
  1493.     addr->wc_head = NULL;
  1494.     addr->wc_tail = NULL;
  1495. #if (NGX_PCRE)
  1496.     addr->nregex = 0;
  1497.     addr->regex = NULL;
  1498. #endif
  1499.     addr->default_server = cscf;
  1500.     addr->servers.elts = NULL;

  1502.     return ngx_http_add_server(cf, cscf, addr);
  1503. }


  1506. /* add the server core module configuration to the address:port */

  1508. static ngx_int_t
  1509. ‌ngx_http_add_server(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
  1510.     ngx_http_conf_addr_t *addr)
  1511. {
  1512.     ngx_uint_t                  i;
  1513.     ngx_http_core_srv_conf_t  **server;

  1515.     if (addr->servers.elts == NULL) {
  1516.         if (ngx_array_init(&addr->servers, cf->temp_pool, 4,
  1517.                            sizeof(ngx_http_core_srv_conf_t *))
  1518.             != NGX_OK)
  1519.         {
  1520.             return NGX_ERROR;
  1521.         }

  1523.     } else {
  1524.         server = addr->servers.elts;
  1525.         for (i = 0; i < addr->servers.nelts; i++) {
  1526.             if (server[i] == cscf) {
  1527.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1528.                                    "a duplicate listen %V",
  1529.                                    &addr->opt.addr_text);
  1530.                 return NGX_ERROR;
  1531.             }
  1532.         }
  1533.     }

  1535.     server = ngx_array_push(&addr->servers);
  1536.     if (server == NULL) {
  1537.         return NGX_ERROR;
  1538.     }

  1540.     *server = cscf;

  1542.     return NGX_OK;
  1543. }


  1546. static ngx_int_t
  1547. ‌ngx_http_optimize_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
  1548.     ngx_array_t *ports)
  1549. {
  1550.     ngx_uint_t             p, a;
  1551.     ngx_http_conf_port_t  *port;
  1552.     ngx_http_conf_addr_t  *addr;

  1554.     if (ports == NULL) {
  1555.         return NGX_OK;
  1556.     }

  1558.     port = ports->elts;
  1559.     for (p = 0; p < ports->nelts; p++) {

  1561.         ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
  1562.                  sizeof(ngx_http_conf_addr_t), ngx_http_cmp_conf_addrs);

  1564.         /*
  1565.          * check whether all name-based servers have the same
  1566.          * configuration as a default server for given address:port
  1567.          */

  1569.         addr = port[p].addrs.elts;
  1570.         for (a = 0; a < port[p].addrs.nelts; a++) {

  1572.             if (addr[a].servers.nelts > 1
  1573. #if (NGX_PCRE)
  1574.                 || addr[a].default_server->captures
  1575. #endif
  1576.                )
  1577.             {
  1578.                 if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) {
  1579.                     return NGX_ERROR;
  1580.                 }
  1581.             }
  1582.         }

  1584.         if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) {
  1585.             return NGX_ERROR;
  1586.         }
  1587.     }

  1589.     return NGX_OK;
  1590. }


  1593. static ngx_int_t
  1594. ‌ngx_http_server_names(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
  1595.     ngx_http_conf_addr_t *addr)
  1596. {
  1597.     ngx_int_t                   rc;
  1598.     ngx_uint_t                  n, s;
  1599.     ngx_hash_init_t             hash;
  1600.     ngx_hash_keys_arrays_t      ha;
  1601.     ngx_http_server_name_t     *name;
  1602.     ngx_http_core_srv_conf_t  **cscfp;
  1603. #if (NGX_PCRE)
  1604.     ngx_uint_t                  regex, i;

  1606.     regex = 0;
  1607. #endif

  1609.     ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t));

  1611.     ha.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
  1612.     if (ha.temp_pool == NULL) {
  1613.         return NGX_ERROR;
  1614.     }

  1616.     ha.pool = cf->pool;

  1618.     if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) {
  1619.         goto failed;
  1620.     }

  1622.     cscfp = addr->servers.elts;

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

  1626.         name = cscfp[s]->server_names.elts;

  1628.         for (n = 0; n < cscfp[s]->server_names.nelts; n++) {

  1630. #if (NGX_PCRE)
  1631.             if (name[n].regex) {
  1632.                 regex++;
  1633.                 continue;
  1634.             }
  1635. #endif

  1637.             rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,
  1638.                                   NGX_HASH_WILDCARD_KEY);

  1640.             if (rc == NGX_ERROR) {
  1641.                 goto failed;
  1642.             }

  1644.             if (rc == NGX_DECLINED) {
  1645.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  1646.                               "invalid server name or wildcard \"%V\" on %V",
  1647.                               &name[n].name, &addr->opt.addr_text);
  1648.                 goto failed;
  1649.             }

  1651.             if (rc == NGX_BUSY) {
  1652.                 ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  1653.                               "conflicting server name \"%V\" on %V, ignored",
  1654.                               &name[n].name, &addr->opt.addr_text);
  1655.             }
  1656.         }
  1657.     }

  1659.     hash.key = ngx_hash_key_lc;
  1660.     hash.max_size = cmcf->server_names_hash_max_size;
  1661.     hash.bucket_size = cmcf->server_names_hash_bucket_size;
  1662.     hash.name = "server_names_hash";
  1663.     hash.pool = cf->pool;

  1665.     if (ha.keys.nelts) {
  1666.         hash.hash = &addr->hash;
  1667.         hash.temp_pool = NULL;

  1669.         if (ngx_hash_init(&hash, ha.keys.elts, ha.keys.nelts) != NGX_OK) {
  1670.             goto failed;
  1671.         }
  1672.     }

  1674.     if (ha.dns_wc_head.nelts) {

  1676.         ngx_qsort(ha.dns_wc_head.elts, (size_t) ha.dns_wc_head.nelts,
  1677.                   sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);

  1679.         hash.hash = NULL;
  1680.         hash.temp_pool = ha.temp_pool;

  1682.         if (ngx_hash_wildcard_init(&hash, ha.dns_wc_head.elts,
  1683.                                    ha.dns_wc_head.nelts)
  1684.             != NGX_OK)
  1685.         {
  1686.             goto failed;
  1687.         }

  1689.         addr->wc_head = (ngx_hash_wildcard_t *) hash.hash;
  1690.     }

  1692.     if (ha.dns_wc_tail.nelts) {

  1694.         ngx_qsort(ha.dns_wc_tail.elts, (size_t) ha.dns_wc_tail.nelts,
  1695.                   sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);

  1697.         hash.hash = NULL;
  1698.         hash.temp_pool = ha.temp_pool;

  1700.         if (ngx_hash_wildcard_init(&hash, ha.dns_wc_tail.elts,
  1701.                                    ha.dns_wc_tail.nelts)
  1702.             != NGX_OK)
  1703.         {
  1704.             goto failed;
  1705.         }

  1707.         addr->wc_tail = (ngx_hash_wildcard_t *) hash.hash;
  1708.     }

  1710.     ngx_destroy_pool(ha.temp_pool);

  1712. #if (NGX_PCRE)

  1714.     if (regex == 0) {
  1715.         return NGX_OK;
  1716.     }

  1718.     addr->nregex = regex;
  1719.     addr->regex = ngx_palloc(cf->pool, regex * sizeof(ngx_http_server_name_t));
  1720.     if (addr->regex == NULL) {
  1721.         return NGX_ERROR;
  1722.     }

  1724.     i = 0;

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

  1728.         name = cscfp[s]->server_names.elts;

  1730.         for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
  1731.             if (name[n].regex) {
  1732.                 addr->regex[i++] = name[n];
  1733.             }
  1734.         }
  1735.     }

  1737. #endif

  1739.     return NGX_OK;

  1741. failed:

  1743.     ngx_destroy_pool(ha.temp_pool);

  1745.     return NGX_ERROR;
  1746. }


  1749. static ngx_int_t
  1750. ‌ngx_http_cmp_conf_addrs(const void *one, const void *two)
  1751. {
  1752.     ngx_http_conf_addr_t  *first, *second;

  1754.     first = (ngx_http_conf_addr_t *) one;
  1755.     second = (ngx_http_conf_addr_t *) two;

  1757.     if (first->opt.wildcard) {
  1758.         /* a wildcard address must be the last resort, shift it to the end */
  1759.         return 1;
  1760.     }

  1762.     if (second->opt.wildcard) {
  1763.         /* a wildcard address must be the last resort, shift it to the end */
  1764.         return -1;
  1765.     }

  1767.     if (first->opt.bind && !second->opt.bind) {
  1768.         /* shift explicit bind()ed addresses to the start */
  1769.         return -1;
  1770.     }

  1772.     if (!first->opt.bind && second->opt.bind) {
  1773.         /* shift explicit bind()ed addresses to the start */
  1774.         return 1;
  1775.     }

  1777.     /* do not sort by default */

  1779.     return 0;
  1780. }


  1783. static int ngx_libc_cdecl
  1784. ‌ngx_http_cmp_dns_wildcards(const void *one, const void *two)
  1785. {
  1786.     ngx_hash_key_t  *first, *second;

  1788.     first = (ngx_hash_key_t *) one;
  1789.     second = (ngx_hash_key_t *) two;

  1791.     return ngx_dns_strcmp(first->key.data, second->key.data);
  1792. }


  1795. static ngx_int_t
  1796. ‌ngx_http_init_listening(ngx_conf_t *cf, ngx_http_conf_port_t *port)
  1797. {
  1798.     ngx_uint_t                 i, last, bind_wildcard;
  1799.     ngx_listening_t           *ls;
  1800.     ngx_http_port_t           *hport;
  1801.     ngx_http_conf_addr_t      *addr;

  1803.     addr = port->addrs.elts;
  1804.     last = port->addrs.nelts;

  1806.     /*
  1807.      * If there is a binding to an "*:port" then we need to bind() to
  1808.      * the "*:port" only and ignore other implicit bindings.  The bindings
  1809.      * have been already sorted: explicit bindings are on the start, then
  1810.      * implicit bindings go, and wildcard binding is in the end.
  1811.      */

  1813.     if (addr[last - 1].opt.wildcard) {
  1814.         addr[last - 1].opt.bind = 1;
  1815.         bind_wildcard = 1;

  1817.     } else {
  1818.         bind_wildcard = 0;
  1819.     }

  1821.     i = 0;

  1823.     while (i < last) {

  1825.         if (bind_wildcard && !addr[i].opt.bind) {
  1826.             i++;
  1827.             continue;
  1828.         }

  1830.         ls = ngx_http_add_listening(cf, &addr[i]);
  1831.         if (ls == NULL) {
  1832.             return NGX_ERROR;
  1833.         }

  1835.         hport = ngx_pcalloc(cf->pool, sizeof(ngx_http_port_t));
  1836.         if (hport == NULL) {
  1837.             return NGX_ERROR;
  1838.         }

  1840.         ls->servers = hport;

  1842.         hport->naddrs = i + 1;

  1844.         switch (ls->sockaddr->sa_family) {

  1846. #if (NGX_HAVE_INET6)
  1847.         case AF_INET6:
  1848.             if (ngx_http_add_addrs6(cf, hport, addr) != NGX_OK) {
  1849.                 return NGX_ERROR;
  1850.             }
  1851.             break;
  1852. #endif
  1853.         default: /* AF_INET */
  1854.             if (ngx_http_add_addrs(cf, hport, addr) != NGX_OK) {
  1855.                 return NGX_ERROR;
  1856.             }
  1857.             break;
  1858.         }

  1860.         addr++;
  1861.         last--;
  1862.     }

  1864.     return NGX_OK;
  1865. }


  1868. static ngx_listening_t *
  1869. ‌ngx_http_add_listening(ngx_conf_t *cf, ngx_http_conf_addr_t *addr)
  1870. {
  1871.     ngx_listening_t           *ls;
  1872.     ngx_http_core_loc_conf_t  *clcf;
  1873.     ngx_http_core_srv_conf_t  *cscf;

  1875.     ls = ngx_create_listening(cf, addr->opt.sockaddr, addr->opt.socklen);
  1876.     if (ls == NULL) {
  1877.         return NULL;
  1878.     }

  1880.     ls->addr_ntop = 1;

  1882.     ls->handler = ngx_http_init_connection;

  1884.     cscf = addr->default_server;
  1885.     ls->pool_size = cscf->connection_pool_size;

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

  1889.     ls->logp = clcf->error_log;
  1890.     ls->log.data = &ls->addr_text;
  1891.     ls->log.handler = ngx_accept_log_error;

  1893. #if (NGX_WIN32)
  1894.     {
  1895.     ngx_iocp_conf_t  *iocpcf = NULL;

  1897.     if (ngx_get_conf(cf->cycle->conf_ctx, ngx_events_module)) {
  1898.         iocpcf = ngx_event_get_conf(cf->cycle->conf_ctx, ngx_iocp_module);
  1899.     }
  1900.     if (iocpcf && iocpcf->acceptex_read) {
  1901.         ls->post_accept_buffer_size = cscf->client_header_buffer_size;
  1902.     }
  1903.     }
  1904. #endif

  1906.     ls->type = addr->opt.type;
  1907.     ls->protocol = addr->opt.protocol;
  1908.     ls->backlog = addr->opt.backlog;
  1909.     ls->rcvbuf = addr->opt.rcvbuf;
  1910.     ls->sndbuf = addr->opt.sndbuf;

  1912.     ls->keepalive = addr->opt.so_keepalive;
  1913. #if (NGX_HAVE_KEEPALIVE_TUNABLE)
  1914.     ls->keepidle = addr->opt.tcp_keepidle;
  1915.     ls->keepintvl = addr->opt.tcp_keepintvl;
  1916.     ls->keepcnt = addr->opt.tcp_keepcnt;
  1917. #endif

  1919. #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
  1920.     ls->accept_filter = addr->opt.accept_filter;
  1921. #endif

  1923. #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
  1924.     ls->deferred_accept = addr->opt.deferred_accept;
  1925. #endif

  1927. #if (NGX_HAVE_INET6)
  1928.     ls->ipv6only = addr->opt.ipv6only;
  1929. #endif

  1931. #if (NGX_HAVE_SETFIB)
  1932.     ls->setfib = addr->opt.setfib;
  1933. #endif

  1935. #if (NGX_HAVE_TCP_FASTOPEN)
  1936.     ls->fastopen = addr->opt.fastopen;
  1937. #endif

  1939. #if (NGX_HAVE_REUSEPORT)
  1940.     ls->reuseport = addr->opt.reuseport;
  1941. #endif

  1943.     ls->wildcard = addr->opt.wildcard;

  1945. #if (NGX_HTTP_V3)
  1946.     ls->quic = addr->opt.quic;
  1947. #endif

  1949.     return ls;
  1950. }


  1953. static ngx_int_t
  1954. ‌ngx_http_add_addrs(ngx_conf_t *cf, ngx_http_port_t *hport,
  1955.     ngx_http_conf_addr_t *addr)
  1956. {
  1957.     ngx_uint_t                 i;
  1958.     ngx_http_in_addr_t        *addrs;
  1959.     struct sockaddr_in        *sin;
  1960.     ngx_http_virtual_names_t  *vn;

  1962.     hport->addrs = ngx_pcalloc(cf->pool,
  1963.                                hport->naddrs * sizeof(ngx_http_in_addr_t));
  1964.     if (hport->addrs == NULL) {
  1965.         return NGX_ERROR;
  1966.     }

  1968.     addrs = hport->addrs;

  1970.     for (i = 0; i < hport->naddrs; i++) {

  1972.         sin = (struct sockaddr_in *) addr[i].opt.sockaddr;
  1973.         addrs[i].addr = sin->sin_addr.s_addr;
  1974.         addrs[i].conf.default_server = addr[i].default_server;
  1975. #if (NGX_HTTP_SSL)
  1976.         addrs[i].conf.ssl = addr[i].opt.ssl;
  1977. #endif
  1978. #if (NGX_HTTP_V2)
  1979.         addrs[i].conf.http2 = addr[i].opt.http2;
  1980. #endif
  1981. #if (NGX_HTTP_V3)
  1982.         addrs[i].conf.quic = addr[i].opt.quic;
  1983. #endif
  1984.         addrs[i].conf.proxy_protocol = addr[i].opt.proxy_protocol;

  1986.         if (addr[i].hash.buckets == NULL
  1987.             && (addr[i].wc_head == NULL
  1988.                 || addr[i].wc_head->hash.buckets == NULL)
  1989.             && (addr[i].wc_tail == NULL
  1990.                 || addr[i].wc_tail->hash.buckets == NULL)
  1991. #if (NGX_PCRE)
  1992.             && addr[i].nregex == 0
  1993. #endif
  1994.             )
  1995.         {
  1996.             continue;
  1997.         }

  1999.         vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t));
  2000.         if (vn == NULL) {
  2001.             return NGX_ERROR;
  2002.         }

  2004.         addrs[i].conf.virtual_names = vn;

  2006.         vn->names.hash = addr[i].hash;
  2007.         vn->names.wc_head = addr[i].wc_head;
  2008.         vn->names.wc_tail = addr[i].wc_tail;
  2009. #if (NGX_PCRE)
  2010.         vn->nregex = addr[i].nregex;
  2011.         vn->regex = addr[i].regex;
  2012. #endif
  2013.     }

  2015.     return NGX_OK;
  2016. }


  2019. #if (NGX_HAVE_INET6)

  2021. static ngx_int_t
  2022. ‌ngx_http_add_addrs6(ngx_conf_t *cf, ngx_http_port_t *hport,
  2023.     ngx_http_conf_addr_t *addr)
  2024. {
  2025.     ngx_uint_t                 i;
  2026.     ngx_http_in6_addr_t       *addrs6;
  2027.     struct sockaddr_in6       *sin6;
  2028.     ngx_http_virtual_names_t  *vn;

  2030.     hport->addrs = ngx_pcalloc(cf->pool,
  2031.                                hport->naddrs * sizeof(ngx_http_in6_addr_t));
  2032.     if (hport->addrs == NULL) {
  2033.         return NGX_ERROR;
  2034.     }

  2036.     addrs6 = hport->addrs;

  2038.     for (i = 0; i < hport->naddrs; i++) {

  2040.         sin6 = (struct sockaddr_in6 *) addr[i].opt.sockaddr;
  2041.         addrs6[i].addr6 = sin6->sin6_addr;
  2042.         addrs6[i].conf.default_server = addr[i].default_server;
  2043. #if (NGX_HTTP_SSL)
  2044.         addrs6[i].conf.ssl = addr[i].opt.ssl;
  2045. #endif
  2046. #if (NGX_HTTP_V2)
  2047.         addrs6[i].conf.http2 = addr[i].opt.http2;
  2048. #endif
  2049. #if (NGX_HTTP_V3)
  2050.         addrs6[i].conf.quic = addr[i].opt.quic;
  2051. #endif
  2052.         addrs6[i].conf.proxy_protocol = addr[i].opt.proxy_protocol;

  2054.         if (addr[i].hash.buckets == NULL
  2055.             && (addr[i].wc_head == NULL
  2056.                 || addr[i].wc_head->hash.buckets == NULL)
  2057.             && (addr[i].wc_tail == NULL
  2058.                 || addr[i].wc_tail->hash.buckets == NULL)
  2059. #if (NGX_PCRE)
  2060.             && addr[i].nregex == 0
  2061. #endif
  2062.             )
  2063.         {
  2064.             continue;
  2065.         }

  2067.         vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t));
  2068.         if (vn == NULL) {
  2069.             return NGX_ERROR;
  2070.         }

  2072.         addrs6[i].conf.virtual_names = vn;

  2074.         vn->names.hash = addr[i].hash;
  2075.         vn->names.wc_head = addr[i].wc_head;
  2076.         vn->names.wc_tail = addr[i].wc_tail;
  2077. #if (NGX_PCRE)
  2078.         vn->nregex = addr[i].nregex;
  2079.         vn->regex = addr[i].regex;
  2080. #endif
  2081.     }

  2083.     return NGX_OK;
  2084. }

  2086. #endif


  2089. char *
  2090. ‌ngx_http_types_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2091. {
  2092.     char  *p = conf;

  2094.     ngx_array_t     **types;
  2095.     ngx_str_t        *value, *default_type;
  2096.     ngx_uint_t        i, n, hash;
  2097.     ngx_hash_key_t   *type;

  2099.     types = (ngx_array_t **) (p + cmd->offset);

  2101.     if (*types == (void *) -1) {
  2102.         return NGX_CONF_OK;
  2103.     }

  2105.     default_type = cmd->post;

  2107.     if (*types == NULL) {
  2108.         *types = ngx_array_create(cf->temp_pool, 1, sizeof(ngx_hash_key_t));
  2109.         if (*types == NULL) {
  2110.             return NGX_CONF_ERROR;
  2111.         }

  2113.         if (default_type) {
  2114.             type = ngx_array_push(*types);
  2115.             if (type == NULL) {
  2116.                 return NGX_CONF_ERROR;
  2117.             }

  2119.             type->key = *default_type;
  2120.             type->key_hash = ngx_hash_key(default_type->data,
  2121.                                           default_type->len);
  2122.             type->value = (void *) 4;
  2123.         }
  2124.     }

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

  2128.     for (i = 1; i < cf->args->nelts; i++) {

  2130.         if (value[i].len == 1 && value[i].data[0] == '*') {
  2131.             *types = (void *) -1;
  2132.             return NGX_CONF_OK;
  2133.         }

  2135.         hash = ngx_hash_strlow(value[i].data, value[i].data, value[i].len);
  2136.         value[i].data[value[i].len] = '\0';

  2138.         type = (*types)->elts;
  2139.         for (n = 0; n < (*types)->nelts; n++) {

  2141.             if (ngx_strcmp(value[i].data, type[n].key.data) == 0) {
  2142.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  2143.                                    "duplicate MIME type \"%V\"", &value[i]);
  2144.                 goto next;
  2145.             }
  2146.         }

  2148.         type = ngx_array_push(*types);
  2149.         if (type == NULL) {
  2150.             return NGX_CONF_ERROR;
  2151.         }

  2153.         type->key = value[i];
  2154.         type->key_hash = hash;
  2155.         type->value = (void *) 4;

  2157.     next:

  2159.         continue;
  2160.     }

  2162.     return NGX_CONF_OK;
  2163. }


  2166. char *
  2167. ‌ngx_http_merge_types(ngx_conf_t *cf, ngx_array_t **keys, ngx_hash_t *types_hash,
  2168.     ngx_array_t **prev_keys, ngx_hash_t *prev_types_hash,
  2169.     ngx_str_t *default_types)
  2170. {
  2171.     ngx_hash_init_t  hash;

  2173.     if (*keys) {

  2175.         if (*keys == (void *) -1) {
  2176.             return NGX_CONF_OK;
  2177.         }

  2179.         hash.hash = types_hash;
  2180.         hash.key = NULL;
  2181.         hash.max_size = 2048;
  2182.         hash.bucket_size = 64;
  2183.         hash.name = "test_types_hash";
  2184.         hash.pool = cf->pool;
  2185.         hash.temp_pool = NULL;

  2187.         if (ngx_hash_init(&hash, (*keys)->elts, (*keys)->nelts) != NGX_OK) {
  2188.             return NGX_CONF_ERROR;
  2189.         }

  2191.         return NGX_CONF_OK;
  2192.     }

  2194.     if (prev_types_hash->buckets == NULL) {

  2196.         if (*prev_keys == NULL) {

  2198.             if (ngx_http_set_default_types(cf, prev_keys, default_types)
  2199.                 != NGX_OK)
  2200.             {
  2201.                 return NGX_CONF_ERROR;
  2202.             }

  2204.         } else if (*prev_keys == (void *) -1) {
  2205.             *keys = *prev_keys;
  2206.             return NGX_CONF_OK;
  2207.         }

  2209.         hash.hash = prev_types_hash;
  2210.         hash.key = NULL;
  2211.         hash.max_size = 2048;
  2212.         hash.bucket_size = 64;
  2213.         hash.name = "test_types_hash";
  2214.         hash.pool = cf->pool;
  2215.         hash.temp_pool = NULL;

  2217.         if (ngx_hash_init(&hash, (*prev_keys)->elts, (*prev_keys)->nelts)
  2218.             != NGX_OK)
  2219.         {
  2220.             return NGX_CONF_ERROR;
  2221.         }
  2222.     }

  2224.     *types_hash = *prev_types_hash;

  2226.     return NGX_CONF_OK;

  2228. }


  2231. ngx_int_t
  2232. ‌ngx_http_set_default_types(ngx_conf_t *cf, ngx_array_t **types,
  2233.     ngx_str_t *default_type)
  2234. {
  2235.     ngx_hash_key_t  *type;

  2237.     *types = ngx_array_create(cf->temp_pool, 1, sizeof(ngx_hash_key_t));
  2238.     if (*types == NULL) {
  2239.         return NGX_ERROR;
  2240.     }

  2242.     while (default_type->len) {

  2244.         type = ngx_array_push(*types);
  2245.         if (type == NULL) {
  2246.             return NGX_ERROR;
  2247.         }

  2249.         type->key = *default_type;
  2250.         type->key_hash = ngx_hash_key(default_type->data,
  2251.                                       default_type->len);
  2252.         type->value = (void *) 4;

  2254.         default_type++;
  2255.     }

  2257.     return NGX_OK;
  2258. }

One Level Up Top Level