Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_http.c
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) Nginx, Inc.
5  */
6 
7 
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 #include <ngx_http.h>
11 
12 
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);
20 
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);
29 
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_cmp_locations(const ngx_queue_t *one,
41  const ngx_queue_t *two);
42 static ngx_int_t ngx_http_join_exact_locations(ngx_conf_t *cf,
43  ngx_queue_t *locations);
44 static void ngx_http_create_locations_list(ngx_queue_t *locations,
45  ngx_queue_t *q);
46 static ngx_http_location_tree_node_t *
47  ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations,
48  size_t prefix);
49 
50 static ngx_int_t ngx_http_optimize_servers(ngx_conf_t *cf,
51  ngx_http_core_main_conf_t *cmcf, ngx_array_t *ports);
52 static ngx_int_t ngx_http_server_names(ngx_conf_t *cf,
53  ngx_http_core_main_conf_t *cmcf, ngx_http_conf_addr_t *addr);
54 static ngx_int_t ngx_http_cmp_conf_addrs(const void *one, const void *two);
55 static int ngx_libc_cdecl ngx_http_cmp_dns_wildcards(const void *one,
56  const void *two);
57 
58 static ngx_int_t ngx_http_init_listening(ngx_conf_t *cf,
59  ngx_http_conf_port_t *port);
60 static ngx_listening_t *ngx_http_add_listening(ngx_conf_t *cf,
61  ngx_http_conf_addr_t *addr);
62 static ngx_int_t ngx_http_add_addrs(ngx_conf_t *cf, ngx_http_port_t *hport,
63  ngx_http_conf_addr_t *addr);
64 #if (NGX_HAVE_INET6)
65 static ngx_int_t ngx_http_add_addrs6(ngx_conf_t *cf, ngx_http_port_t *hport,
66  ngx_http_conf_addr_t *addr);
67 #endif
68 
69 ngx_uint_t ngx_http_max_module;
70 
71 
72 ngx_int_t (*ngx_http_top_header_filter) (ngx_http_request_t *r);
73 ngx_int_t (*ngx_http_top_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch);
74 
75 
76 ngx_str_t ngx_http_html_default_types[] = {
77  ngx_string("text/html"),
78  ngx_null_string
79 };
80 
81 
82 static ngx_command_t ngx_http_commands[] = {
83 
84  { ngx_string("http"),
85  NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
86  ngx_http_block,
87  0,
88  0,
89  NULL },
90 
91  ngx_null_command
92 };
93 
94 
95 static ngx_core_module_t ngx_http_module_ctx = {
96  ngx_string("http"),
97  NULL,
98  NULL
99 };
100 
101 
102 ngx_module_t ngx_http_module = {
103  NGX_MODULE_V1,
104  &ngx_http_module_ctx, /* module context */
105  ngx_http_commands, /* module directives */
106  NGX_CORE_MODULE, /* module type */
107  NULL, /* init master */
108  NULL, /* init module */
109  NULL, /* init process */
110  NULL, /* init thread */
111  NULL, /* exit thread */
112  NULL, /* exit process */
113  NULL, /* exit master */
114  NGX_MODULE_V1_PADDING
115 };
116 
117 
118 static char *
119 ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
120 {
121  char *rv;
122  ngx_uint_t mi, m, s;
123  ngx_conf_t pcf;
124  ngx_http_module_t *module;
125  ngx_http_conf_ctx_t *ctx;
126  ngx_http_core_loc_conf_t *clcf;
127  ngx_http_core_srv_conf_t **cscfp;
128  ngx_http_core_main_conf_t *cmcf;
129 
130  /* the main http context */
131 
132  ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
133  if (ctx == NULL) {
134  return NGX_CONF_ERROR;
135  }
136 
137  *(ngx_http_conf_ctx_t **) conf = ctx;
138 
139 
140  /* count the number of the http modules and set up their indices */
141 
142  ngx_http_max_module = 0;
143  for (m = 0; ngx_modules[m]; m++) {
144  if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
145  continue;
146  }
147 
148  ngx_modules[m]->ctx_index = ngx_http_max_module++;
149  }
150 
151 
152  /* the http main_conf context, it is the same in the all http contexts */
153 
154  ctx->main_conf = ngx_pcalloc(cf->pool,
155  sizeof(void *) * ngx_http_max_module);
156  if (ctx->main_conf == NULL) {
157  return NGX_CONF_ERROR;
158  }
159 
160 
161  /*
162  * the http null srv_conf context, it is used to merge
163  * the server{}s' srv_conf's
164  */
165 
166  ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
167  if (ctx->srv_conf == NULL) {
168  return NGX_CONF_ERROR;
169  }
170 
171 
172  /*
173  * the http null loc_conf context, it is used to merge
174  * the server{}s' loc_conf's
175  */
176 
177  ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
178  if (ctx->loc_conf == NULL) {
179  return NGX_CONF_ERROR;
180  }
181 
182 
183  /*
184  * create the main_conf's, the null srv_conf's, and the null loc_conf's
185  * of the all http modules
186  */
187 
188  for (m = 0; ngx_modules[m]; m++) {
189  if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
190  continue;
191  }
192 
193  module = ngx_modules[m]->ctx;
194  mi = ngx_modules[m]->ctx_index;
195 
196  if (module->create_main_conf) {
197  ctx->main_conf[mi] = module->create_main_conf(cf);
198  if (ctx->main_conf[mi] == NULL) {
199  return NGX_CONF_ERROR;
200  }
201  }
202 
203  if (module->create_srv_conf) {
204  ctx->srv_conf[mi] = module->create_srv_conf(cf);
205  if (ctx->srv_conf[mi] == NULL) {
206  return NGX_CONF_ERROR;
207  }
208  }
209 
210  if (module->create_loc_conf) {
211  ctx->loc_conf[mi] = module->create_loc_conf(cf);
212  if (ctx->loc_conf[mi] == NULL) {
213  return NGX_CONF_ERROR;
214  }
215  }
216  }
217 
218  pcf = *cf;
219  cf->ctx = ctx;
220 
221  for (m = 0; ngx_modules[m]; m++) {
222  if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
223  continue;
224  }
225 
226  module = ngx_modules[m]->ctx;
227 
228  if (module->preconfiguration) {
229  if (module->preconfiguration(cf) != NGX_OK) {
230  return NGX_CONF_ERROR;
231  }
232  }
233  }
234 
235  /* parse inside the http{} block */
236 
237  cf->module_type = NGX_HTTP_MODULE;
238  cf->cmd_type = NGX_HTTP_MAIN_CONF;
239  rv = ngx_conf_parse(cf, NULL);
240 
241  if (rv != NGX_CONF_OK) {
242  goto failed;
243  }
244 
245  /*
246  * init http{} main_conf's, merge the server{}s' srv_conf's
247  * and its location{}s' loc_conf's
248  */
249 
250  cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
251  cscfp = cmcf->servers.elts;
252 
253  for (m = 0; ngx_modules[m]; m++) {
254  if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
255  continue;
256  }
257 
258  module = ngx_modules[m]->ctx;
259  mi = ngx_modules[m]->ctx_index;
260 
261  /* init http{} main_conf's */
262 
263  if (module->init_main_conf) {
264  rv = module->init_main_conf(cf, ctx->main_conf[mi]);
265  if (rv != NGX_CONF_OK) {
266  goto failed;
267  }
268  }
269 
270  rv = ngx_http_merge_servers(cf, cmcf, module, mi);
271  if (rv != NGX_CONF_OK) {
272  goto failed;
273  }
274  }
275 
276 
277  /* create location trees */
278 
279  for (s = 0; s < cmcf->servers.nelts; s++) {
280 
281  clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];
282 
283  if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) {
284  return NGX_CONF_ERROR;
285  }
286 
287  if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
288  return NGX_CONF_ERROR;
289  }
290  }
291 
292 
293  if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
294  return NGX_CONF_ERROR;
295  }
296 
297  if (ngx_http_init_headers_in_hash(cf, cmcf) != NGX_OK) {
298  return NGX_CONF_ERROR;
299  }
300 
301 
302  for (m = 0; ngx_modules[m]; m++) {
303  if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
304  continue;
305  }
306 
307  module = ngx_modules[m]->ctx;
308 
309  if (module->postconfiguration) {
310  if (module->postconfiguration(cf) != NGX_OK) {
311  return NGX_CONF_ERROR;
312  }
313  }
314  }
315 
316  if (ngx_http_variables_init_vars(cf) != NGX_OK) {
317  return NGX_CONF_ERROR;
318  }
319 
320  /*
321  * http{}'s cf->ctx was needed while the configuration merging
322  * and in postconfiguration process
323  */
324 
325  *cf = pcf;
326 
327 
328  if (ngx_http_init_phase_handlers(cf, cmcf) != NGX_OK) {
329  return NGX_CONF_ERROR;
330  }
331 
332 
333  /* optimize the lists of ports, addresses and server names */
334 
335  if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
336  return NGX_CONF_ERROR;
337  }
338 
339  return NGX_CONF_OK;
340 
341 failed:
342 
343  *cf = pcf;
344 
345  return rv;
346 }
347 
348 
349 static ngx_int_t
350 ngx_http_init_phases(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
351 {
352  if (ngx_array_init(&cmcf->phases[NGX_HTTP_POST_READ_PHASE].handlers,
353  cf->pool, 1, sizeof(ngx_http_handler_pt))
354  != NGX_OK)
355  {
356  return NGX_ERROR;
357  }
358 
359  if (ngx_array_init(&cmcf->phases[NGX_HTTP_SERVER_REWRITE_PHASE].handlers,
360  cf->pool, 1, sizeof(ngx_http_handler_pt))
361  != NGX_OK)
362  {
363  return NGX_ERROR;
364  }
365 
366  if (ngx_array_init(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers,
367  cf->pool, 1, sizeof(ngx_http_handler_pt))
368  != NGX_OK)
369  {
370  return NGX_ERROR;
371  }
372 
373  if (ngx_array_init(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers,
374  cf->pool, 1, sizeof(ngx_http_handler_pt))
375  != NGX_OK)
376  {
377  return NGX_ERROR;
378  }
379 
380  if (ngx_array_init(&cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers,
381  cf->pool, 2, sizeof(ngx_http_handler_pt))
382  != NGX_OK)
383  {
384  return NGX_ERROR;
385  }
386 
387  if (ngx_array_init(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers,
388  cf->pool, 4, sizeof(ngx_http_handler_pt))
389  != NGX_OK)
390  {
391  return NGX_ERROR;
392  }
393 
394  if (ngx_array_init(&cmcf->phases[NGX_HTTP_LOG_PHASE].handlers,
395  cf->pool, 1, sizeof(ngx_http_handler_pt))
396  != NGX_OK)
397  {
398  return NGX_ERROR;
399  }
400 
401  return NGX_OK;
402 }
403 
404 
405 static ngx_int_t
406 ngx_http_init_headers_in_hash(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
407 {
408  ngx_array_t headers_in;
409  ngx_hash_key_t *hk;
410  ngx_hash_init_t hash;
411  ngx_http_header_t *header;
412 
413  if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
414  != NGX_OK)
415  {
416  return NGX_ERROR;
417  }
418 
419  for (header = ngx_http_headers_in; header->name.len; header++) {
420  hk = ngx_array_push(&headers_in);
421  if (hk == NULL) {
422  return NGX_ERROR;
423  }
424 
425  hk->key = header->name;
426  hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
427  hk->value = header;
428  }
429 
430  hash.hash = &cmcf->headers_in_hash;
431  hash.key = ngx_hash_key_lc;
432  hash.max_size = 512;
433  hash.bucket_size = ngx_align(64, ngx_cacheline_size);
434  hash.name = "headers_in_hash";
435  hash.pool = cf->pool;
436  hash.temp_pool = NULL;
437 
438  if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
439  return NGX_ERROR;
440  }
441 
442  return NGX_OK;
443 }
444 
445 
446 static ngx_int_t
447 ngx_http_init_phase_handlers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf)
448 {
449  ngx_int_t j;
450  ngx_uint_t i, n;
451  ngx_uint_t find_config_index, use_rewrite, use_access;
452  ngx_http_handler_pt *h;
453  ngx_http_phase_handler_t *ph;
454  ngx_http_phase_handler_pt checker;
455 
456  cmcf->phase_engine.server_rewrite_index = (ngx_uint_t) -1;
457  cmcf->phase_engine.location_rewrite_index = (ngx_uint_t) -1;
458  find_config_index = 0;
459  use_rewrite = cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers.nelts ? 1 : 0;
460  use_access = cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers.nelts ? 1 : 0;
461 
462  n = use_rewrite + use_access + cmcf->try_files + 1 /* find config phase */;
463 
464  for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) {
465  n += cmcf->phases[i].handlers.nelts;
466  }
467 
468  ph = ngx_pcalloc(cf->pool,
469  n * sizeof(ngx_http_phase_handler_t) + sizeof(void *));
470  if (ph == NULL) {
471  return NGX_ERROR;
472  }
473 
474  cmcf->phase_engine.handlers = ph;
475  n = 0;
476 
477  for (i = 0; i < NGX_HTTP_LOG_PHASE; i++) {
478  h = cmcf->phases[i].handlers.elts;
479 
480  switch (i) {
481 
482  case NGX_HTTP_SERVER_REWRITE_PHASE:
483  if (cmcf->phase_engine.server_rewrite_index == (ngx_uint_t) -1) {
484  cmcf->phase_engine.server_rewrite_index = n;
485  }
486  checker = ngx_http_core_rewrite_phase;
487 
488  break;
489 
490  case NGX_HTTP_FIND_CONFIG_PHASE:
491  find_config_index = n;
492 
493  ph->checker = ngx_http_core_find_config_phase;
494  n++;
495  ph++;
496 
497  continue;
498 
499  case NGX_HTTP_REWRITE_PHASE:
500  if (cmcf->phase_engine.location_rewrite_index == (ngx_uint_t) -1) {
501  cmcf->phase_engine.location_rewrite_index = n;
502  }
503  checker = ngx_http_core_rewrite_phase;
504 
505  break;
506 
507  case NGX_HTTP_POST_REWRITE_PHASE:
508  if (use_rewrite) {
509  ph->checker = ngx_http_core_post_rewrite_phase;
510  ph->next = find_config_index;
511  n++;
512  ph++;
513  }
514 
515  continue;
516 
517  case NGX_HTTP_ACCESS_PHASE:
518  checker = ngx_http_core_access_phase;
519  n++;
520  break;
521 
522  case NGX_HTTP_POST_ACCESS_PHASE:
523  if (use_access) {
524  ph->checker = ngx_http_core_post_access_phase;
525  ph->next = n;
526  ph++;
527  }
528 
529  continue;
530 
531  case NGX_HTTP_TRY_FILES_PHASE:
532  if (cmcf->try_files) {
533  ph->checker = ngx_http_core_try_files_phase;
534  n++;
535  ph++;
536  }
537 
538  continue;
539 
540  case NGX_HTTP_CONTENT_PHASE:
541  checker = ngx_http_core_content_phase;
542  break;
543 
544  default:
545  checker = ngx_http_core_generic_phase;
546  }
547 
548  n += cmcf->phases[i].handlers.nelts;
549 
550  for (j = cmcf->phases[i].handlers.nelts - 1; j >=0; j--) {
551  ph->checker = checker;
552  ph->handler = h[j];
553  ph->next = n;
554  ph++;
555  }
556  }
557 
558  return NGX_OK;
559 }
560 
561 
562 static char *
563 ngx_http_merge_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
564  ngx_http_module_t *module, ngx_uint_t ctx_index)
565 {
566  char *rv;
567  ngx_uint_t s;
568  ngx_http_conf_ctx_t *ctx, saved;
569  ngx_http_core_loc_conf_t *clcf;
570  ngx_http_core_srv_conf_t **cscfp;
571 
572  cscfp = cmcf->servers.elts;
573  ctx = (ngx_http_conf_ctx_t *) cf->ctx;
574  saved = *ctx;
575  rv = NGX_CONF_OK;
576 
577  for (s = 0; s < cmcf->servers.nelts; s++) {
578 
579  /* merge the server{}s' srv_conf's */
580 
581  ctx->srv_conf = cscfp[s]->ctx->srv_conf;
582 
583  if (module->merge_srv_conf) {
584  rv = module->merge_srv_conf(cf, saved.srv_conf[ctx_index],
585  cscfp[s]->ctx->srv_conf[ctx_index]);
586  if (rv != NGX_CONF_OK) {
587  goto failed;
588  }
589  }
590 
591  if (module->merge_loc_conf) {
592 
593  /* merge the server{}'s loc_conf */
594 
595  ctx->loc_conf = cscfp[s]->ctx->loc_conf;
596 
597  rv = module->merge_loc_conf(cf, saved.loc_conf[ctx_index],
598  cscfp[s]->ctx->loc_conf[ctx_index]);
599  if (rv != NGX_CONF_OK) {
600  goto failed;
601  }
602 
603  /* merge the locations{}' loc_conf's */
604 
605  clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];
606 
607  rv = ngx_http_merge_locations(cf, clcf->locations,
608  cscfp[s]->ctx->loc_conf,
609  module, ctx_index);
610  if (rv != NGX_CONF_OK) {
611  goto failed;
612  }
613  }
614  }
615 
616 failed:
617 
618  *ctx = saved;
619 
620  return rv;
621 }
622 
623 
624 static char *
625 ngx_http_merge_locations(ngx_conf_t *cf, ngx_queue_t *locations,
626  void **loc_conf, ngx_http_module_t *module, ngx_uint_t ctx_index)
627 {
628  char *rv;
629  ngx_queue_t *q;
630  ngx_http_conf_ctx_t *ctx, saved;
631  ngx_http_core_loc_conf_t *clcf;
632  ngx_http_location_queue_t *lq;
633 
634  if (locations == NULL) {
635  return NGX_CONF_OK;
636  }
637 
638  ctx = (ngx_http_conf_ctx_t *) cf->ctx;
639  saved = *ctx;
640 
641  for (q = ngx_queue_head(locations);
642  q != ngx_queue_sentinel(locations);
643  q = ngx_queue_next(q))
644  {
645  lq = (ngx_http_location_queue_t *) q;
646 
647  clcf = lq->exact ? lq->exact : lq->inclusive;
648  ctx->loc_conf = clcf->loc_conf;
649 
650  rv = module->merge_loc_conf(cf, loc_conf[ctx_index],
651  clcf->loc_conf[ctx_index]);
652  if (rv != NGX_CONF_OK) {
653  return rv;
654  }
655 
656  rv = ngx_http_merge_locations(cf, clcf->locations, clcf->loc_conf,
657  module, ctx_index);
658  if (rv != NGX_CONF_OK) {
659  return rv;
660  }
661  }
662 
663  *ctx = saved;
664 
665  return NGX_CONF_OK;
666 }
667 
668 
669 static ngx_int_t
670 ngx_http_init_locations(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
671  ngx_http_core_loc_conf_t *pclcf)
672 {
673  ngx_uint_t n;
674  ngx_queue_t *q, *locations, *named, tail;
675  ngx_http_core_loc_conf_t *clcf;
676  ngx_http_location_queue_t *lq;
677  ngx_http_core_loc_conf_t **clcfp;
678 #if (NGX_PCRE)
679  ngx_uint_t r;
680  ngx_queue_t *regex;
681 #endif
682 
683  locations = pclcf->locations;
684 
685  if (locations == NULL) {
686  return NGX_OK;
687  }
688 
689  ngx_queue_sort(locations, ngx_http_cmp_locations);
690 
691  named = NULL;
692  n = 0;
693 #if (NGX_PCRE)
694  regex = NULL;
695  r = 0;
696 #endif
697 
698  for (q = ngx_queue_head(locations);
699  q != ngx_queue_sentinel(locations);
700  q = ngx_queue_next(q))
701  {
702  lq = (ngx_http_location_queue_t *) q;
703 
704  clcf = lq->exact ? lq->exact : lq->inclusive;
705 
706  if (ngx_http_init_locations(cf, NULL, clcf) != NGX_OK) {
707  return NGX_ERROR;
708  }
709 
710 #if (NGX_PCRE)
711 
712  if (clcf->regex) {
713  r++;
714 
715  if (regex == NULL) {
716  regex = q;
717  }
718 
719  continue;
720  }
721 
722 #endif
723 
724  if (clcf->named) {
725  n++;
726 
727  if (named == NULL) {
728  named = q;
729  }
730 
731  continue;
732  }
733 
734  if (clcf->noname) {
735  break;
736  }
737  }
738 
739  if (q != ngx_queue_sentinel(locations)) {
740  ngx_queue_split(locations, q, &tail);
741  }
742 
743  if (named) {
744  clcfp = ngx_palloc(cf->pool,
745  (n + 1) * sizeof(ngx_http_core_loc_conf_t **));
746  if (clcfp == NULL) {
747  return NGX_ERROR;
748  }
749 
750  cscf->named_locations = clcfp;
751 
752  for (q = named;
753  q != ngx_queue_sentinel(locations);
754  q = ngx_queue_next(q))
755  {
756  lq = (ngx_http_location_queue_t *) q;
757 
758  *(clcfp++) = lq->exact;
759  }
760 
761  *clcfp = NULL;
762 
763  ngx_queue_split(locations, named, &tail);
764  }
765 
766 #if (NGX_PCRE)
767 
768  if (regex) {
769 
770  clcfp = ngx_palloc(cf->pool,
771  (r + 1) * sizeof(ngx_http_core_loc_conf_t **));
772  if (clcfp == NULL) {
773  return NGX_ERROR;
774  }
775 
776  pclcf->regex_locations = clcfp;
777 
778  for (q = regex;
779  q != ngx_queue_sentinel(locations);
780  q = ngx_queue_next(q))
781  {
782  lq = (ngx_http_location_queue_t *) q;
783 
784  *(clcfp++) = lq->exact;
785  }
786 
787  *clcfp = NULL;
788 
789  ngx_queue_split(locations, regex, &tail);
790  }
791 
792 #endif
793 
794  return NGX_OK;
795 }
796 
797 
798 static ngx_int_t
799 ngx_http_init_static_location_trees(ngx_conf_t *cf,
800  ngx_http_core_loc_conf_t *pclcf)
801 {
802  ngx_queue_t *q, *locations;
803  ngx_http_core_loc_conf_t *clcf;
804  ngx_http_location_queue_t *lq;
805 
806  locations = pclcf->locations;
807 
808  if (locations == NULL) {
809  return NGX_OK;
810  }
811 
812  if (ngx_queue_empty(locations)) {
813  return NGX_OK;
814  }
815 
816  for (q = ngx_queue_head(locations);
817  q != ngx_queue_sentinel(locations);
818  q = ngx_queue_next(q))
819  {
820  lq = (ngx_http_location_queue_t *) q;
821 
822  clcf = lq->exact ? lq->exact : lq->inclusive;
823 
824  if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
825  return NGX_ERROR;
826  }
827  }
828 
829  if (ngx_http_join_exact_locations(cf, locations) != NGX_OK) {
830  return NGX_ERROR;
831  }
832 
833  ngx_http_create_locations_list(locations, ngx_queue_head(locations));
834 
835  pclcf->static_locations = ngx_http_create_locations_tree(cf, locations, 0);
836  if (pclcf->static_locations == NULL) {
837  return NGX_ERROR;
838  }
839 
840  return NGX_OK;
841 }
842 
843 
844 ngx_int_t
845 ngx_http_add_location(ngx_conf_t *cf, ngx_queue_t **locations,
846  ngx_http_core_loc_conf_t *clcf)
847 {
848  ngx_http_location_queue_t *lq;
849 
850  if (*locations == NULL) {
851  *locations = ngx_palloc(cf->temp_pool,
852  sizeof(ngx_http_location_queue_t));
853  if (*locations == NULL) {
854  return NGX_ERROR;
855  }
856 
857  ngx_queue_init(*locations);
858  }
859 
860  lq = ngx_palloc(cf->temp_pool, sizeof(ngx_http_location_queue_t));
861  if (lq == NULL) {
862  return NGX_ERROR;
863  }
864 
865  if (clcf->exact_match
866 #if (NGX_PCRE)
867  || clcf->regex
868 #endif
869  || clcf->named || clcf->noname)
870  {
871  lq->exact = clcf;
872  lq->inclusive = NULL;
873 
874  } else {
875  lq->exact = NULL;
876  lq->inclusive = clcf;
877  }
878 
879  lq->name = &clcf->name;
880  lq->file_name = cf->conf_file->file.name.data;
881  lq->line = cf->conf_file->line;
882 
883  ngx_queue_init(&lq->list);
884 
885  ngx_queue_insert_tail(*locations, &lq->queue);
886 
887  return NGX_OK;
888 }
889 
890 
891 static ngx_int_t
892 ngx_http_cmp_locations(const ngx_queue_t *one, const ngx_queue_t *two)
893 {
894  ngx_int_t rc;
895  ngx_http_core_loc_conf_t *first, *second;
896  ngx_http_location_queue_t *lq1, *lq2;
897 
898  lq1 = (ngx_http_location_queue_t *) one;
899  lq2 = (ngx_http_location_queue_t *) two;
900 
901  first = lq1->exact ? lq1->exact : lq1->inclusive;
902  second = lq2->exact ? lq2->exact : lq2->inclusive;
903 
904  if (first->noname && !second->noname) {
905  /* shift no named locations to the end */
906  return 1;
907  }
908 
909  if (!first->noname && second->noname) {
910  /* shift no named locations to the end */
911  return -1;
912  }
913 
914  if (first->noname || second->noname) {
915  /* do not sort no named locations */
916  return 0;
917  }
918 
919  if (first->named && !second->named) {
920  /* shift named locations to the end */
921  return 1;
922  }
923 
924  if (!first->named && second->named) {
925  /* shift named locations to the end */
926  return -1;
927  }
928 
929  if (first->named && second->named) {
930  return ngx_strcmp(first->name.data, second->name.data);
931  }
932 
933 #if (NGX_PCRE)
934 
935  if (first->regex && !second->regex) {
936  /* shift the regex matches to the end */
937  return 1;
938  }
939 
940  if (!first->regex && second->regex) {
941  /* shift the regex matches to the end */
942  return -1;
943  }
944 
945  if (first->regex || second->regex) {
946  /* do not sort the regex matches */
947  return 0;
948  }
949 
950 #endif
951 
952  rc = ngx_strcmp(first->name.data, second->name.data);
953 
954  if (rc == 0 && !first->exact_match && second->exact_match) {
955  /* an exact match must be before the same inclusive one */
956  return 1;
957  }
958 
959  return rc;
960 }
961 
962 
963 static ngx_int_t
964 ngx_http_join_exact_locations(ngx_conf_t *cf, ngx_queue_t *locations)
965 {
966  ngx_queue_t *q, *x;
967  ngx_http_location_queue_t *lq, *lx;
968 
969  q = ngx_queue_head(locations);
970 
971  while (q != ngx_queue_last(locations)) {
972 
973  x = ngx_queue_next(q);
974 
975  lq = (ngx_http_location_queue_t *) q;
976  lx = (ngx_http_location_queue_t *) x;
977 
978  if (ngx_strcmp(lq->name->data, lx->name->data) == 0) {
979 
980  if ((lq->exact && lx->exact) || (lq->inclusive && lx->inclusive)) {
981  ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
982  "duplicate location \"%V\" in %s:%ui",
983  lx->name, lx->file_name, lx->line);
984 
985  return NGX_ERROR;
986  }
987 
988  lq->inclusive = lx->inclusive;
989 
990  ngx_queue_remove(x);
991 
992  continue;
993  }
994 
995  q = ngx_queue_next(q);
996  }
997 
998  return NGX_OK;
999 }
1000 
1001 
1002 static void
1003 ngx_http_create_locations_list(ngx_queue_t *locations, ngx_queue_t *q)
1004 {
1005  u_char *name;
1006  size_t len;
1007  ngx_queue_t *x, tail;
1008  ngx_http_location_queue_t *lq, *lx;
1009 
1010  if (q == ngx_queue_last(locations)) {
1011  return;
1012  }
1013 
1014  lq = (ngx_http_location_queue_t *) q;
1015 
1016  if (lq->inclusive == NULL) {
1017  ngx_http_create_locations_list(locations, ngx_queue_next(q));
1018  return;
1019  }
1020 
1021  len = lq->name->len;
1022  name = lq->name->data;
1023 
1024  for (x = ngx_queue_next(q);
1025  x != ngx_queue_sentinel(locations);
1026  x = ngx_queue_next(x))
1027  {
1028  lx = (ngx_http_location_queue_t *) x;
1029 
1030  if (len > lx->name->len
1031  || (ngx_strncmp(name, lx->name->data, len) != 0))
1032  {
1033  break;
1034  }
1035  }
1036 
1037  q = ngx_queue_next(q);
1038 
1039  if (q == x) {
1040  ngx_http_create_locations_list(locations, x);
1041  return;
1042  }
1043 
1044  ngx_queue_split(locations, q, &tail);
1045  ngx_queue_add(&lq->list, &tail);
1046 
1047  if (x == ngx_queue_sentinel(locations)) {
1048  ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
1049  return;
1050  }
1051 
1052  ngx_queue_split(&lq->list, x, &tail);
1053  ngx_queue_add(locations, &tail);
1054 
1055  ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
1056 
1057  ngx_http_create_locations_list(locations, x);
1058 }
1059 
1060 
1061 /*
1062  * to keep cache locality for left leaf nodes, allocate nodes in following
1063  * order: node, left subtree, right subtree, inclusive subtree
1064  */
1065 
1066 static ngx_http_location_tree_node_t *
1067 ngx_http_create_locations_tree(ngx_conf_t *cf, ngx_queue_t *locations,
1068  size_t prefix)
1069 {
1070  size_t len;
1071  ngx_queue_t *q, tail;
1072  ngx_http_location_queue_t *lq;
1073  ngx_http_location_tree_node_t *node;
1074 
1075  q = ngx_queue_middle(locations);
1076 
1077  lq = (ngx_http_location_queue_t *) q;
1078  len = lq->name->len - prefix;
1079 
1080  node = ngx_palloc(cf->pool,
1081  offsetof(ngx_http_location_tree_node_t, name) + len);
1082  if (node == NULL) {
1083  return NULL;
1084  }
1085 
1086  node->left = NULL;
1087  node->right = NULL;
1088  node->tree = NULL;
1089  node->exact = lq->exact;
1090  node->inclusive = lq->inclusive;
1091 
1092  node->auto_redirect = (u_char) ((lq->exact && lq->exact->auto_redirect)
1093  || (lq->inclusive && lq->inclusive->auto_redirect));
1094 
1095  node->len = (u_char) len;
1096  ngx_memcpy(node->name, &lq->name->data[prefix], len);
1097 
1098  ngx_queue_split(locations, q, &tail);
1099 
1100  if (ngx_queue_empty(locations)) {
1101  /*
1102  * ngx_queue_split() insures that if left part is empty,
1103  * then right one is empty too
1104  */
1105  goto inclusive;
1106  }
1107 
1108  node->left = ngx_http_create_locations_tree(cf, locations, prefix);
1109  if (node->left == NULL) {
1110  return NULL;
1111  }
1112 
1113  ngx_queue_remove(q);
1114 
1115  if (ngx_queue_empty(&tail)) {
1116  goto inclusive;
1117  }
1118 
1119  node->right = ngx_http_create_locations_tree(cf, &tail, prefix);
1120  if (node->right == NULL) {
1121  return NULL;
1122  }
1123 
1124 inclusive:
1125 
1126  if (ngx_queue_empty(&lq->list)) {
1127  return node;
1128  }
1129 
1130  node->tree = ngx_http_create_locations_tree(cf, &lq->list, prefix + len);
1131  if (node->tree == NULL) {
1132  return NULL;
1133  }
1134 
1135  return node;
1136 }
1137 
1138 
1139 ngx_int_t
1140 ngx_http_add_listen(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1141  ngx_http_listen_opt_t *lsopt)
1142 {
1143  in_port_t p;
1144  ngx_uint_t i;
1145  struct sockaddr *sa;
1146  struct sockaddr_in *sin;
1147  ngx_http_conf_port_t *port;
1148  ngx_http_core_main_conf_t *cmcf;
1149 #if (NGX_HAVE_INET6)
1150  struct sockaddr_in6 *sin6;
1151 #endif
1152 
1153  cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
1154 
1155  if (cmcf->ports == NULL) {
1156  cmcf->ports = ngx_array_create(cf->temp_pool, 2,
1157  sizeof(ngx_http_conf_port_t));
1158  if (cmcf->ports == NULL) {
1159  return NGX_ERROR;
1160  }
1161  }
1162 
1163  sa = &lsopt->u.sockaddr;
1164 
1165  switch (sa->sa_family) {
1166 
1167 #if (NGX_HAVE_INET6)
1168  case AF_INET6:
1169  sin6 = &lsopt->u.sockaddr_in6;
1170  p = sin6->sin6_port;
1171  break;
1172 #endif
1173 
1174 #if (NGX_HAVE_UNIX_DOMAIN)
1175  case AF_UNIX:
1176  p = 0;
1177  break;
1178 #endif
1179 
1180  default: /* AF_INET */
1181  sin = &lsopt->u.sockaddr_in;
1182  p = sin->sin_port;
1183  break;
1184  }
1185 
1186  port = cmcf->ports->elts;
1187  for (i = 0; i < cmcf->ports->nelts; i++) {
1188 
1189  if (p != port[i].port || sa->sa_family != port[i].family) {
1190  continue;
1191  }
1192 
1193  /* a port is already in the port list */
1194 
1195  return ngx_http_add_addresses(cf, cscf, &port[i], lsopt);
1196  }
1197 
1198  /* add a port to the port list */
1199 
1200  port = ngx_array_push(cmcf->ports);
1201  if (port == NULL) {
1202  return NGX_ERROR;
1203  }
1204 
1205  port->family = sa->sa_family;
1206  port->port = p;
1207  port->addrs.elts = NULL;
1208 
1209  return ngx_http_add_address(cf, cscf, port, lsopt);
1210 }
1211 
1212 
1213 static ngx_int_t
1214 ngx_http_add_addresses(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1215  ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
1216 {
1217  u_char *p;
1218  size_t len, off;
1219  ngx_uint_t i, default_server;
1220  struct sockaddr *sa;
1221  ngx_http_conf_addr_t *addr;
1222 #if (NGX_HAVE_UNIX_DOMAIN)
1223  struct sockaddr_un *saun;
1224 #endif
1225 #if (NGX_HTTP_SSL)
1226  ngx_uint_t ssl;
1227 #endif
1228 #if (NGX_HTTP_SPDY)
1229  ngx_uint_t spdy;
1230 #endif
1231 
1232  /*
1233  * we cannot compare whole sockaddr struct's as kernel
1234  * may fill some fields in inherited sockaddr struct's
1235  */
1236 
1237  sa = &lsopt->u.sockaddr;
1238 
1239  switch (sa->sa_family) {
1240 
1241 #if (NGX_HAVE_INET6)
1242  case AF_INET6:
1243  off = offsetof(struct sockaddr_in6, sin6_addr);
1244  len = 16;
1245  break;
1246 #endif
1247 
1248 #if (NGX_HAVE_UNIX_DOMAIN)
1249  case AF_UNIX:
1250  off = offsetof(struct sockaddr_un, sun_path);
1251  len = sizeof(saun->sun_path);
1252  break;
1253 #endif
1254 
1255  default: /* AF_INET */
1256  off = offsetof(struct sockaddr_in, sin_addr);
1257  len = 4;
1258  break;
1259  }
1260 
1261  p = lsopt->u.sockaddr_data + off;
1262 
1263  addr = port->addrs.elts;
1264 
1265  for (i = 0; i < port->addrs.nelts; i++) {
1266 
1267  if (ngx_memcmp(p, addr[i].opt.u.sockaddr_data + off, len) != 0) {
1268  continue;
1269  }
1270 
1271  /* the address is already in the address list */
1272 
1273  if (ngx_http_add_server(cf, cscf, &addr[i]) != NGX_OK) {
1274  return NGX_ERROR;
1275  }
1276 
1277  /* preserve default_server bit during listen options overwriting */
1278  default_server = addr[i].opt.default_server;
1279 
1280 #if (NGX_HTTP_SSL)
1281  ssl = lsopt->ssl || addr[i].opt.ssl;
1282 #endif
1283 #if (NGX_HTTP_SPDY)
1284  spdy = lsopt->spdy || addr[i].opt.spdy;
1285 #endif
1286 
1287  if (lsopt->set) {
1288 
1289  if (addr[i].opt.set) {
1290  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1291  "duplicate listen options for %s", addr[i].opt.addr);
1292  return NGX_ERROR;
1293  }
1294 
1295  addr[i].opt = *lsopt;
1296  }
1297 
1298  /* check the duplicate "default" server for this address:port */
1299 
1300  if (lsopt->default_server) {
1301 
1302  if (default_server) {
1303  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1304  "a duplicate default server for %s", addr[i].opt.addr);
1305  return NGX_ERROR;
1306  }
1307 
1308  default_server = 1;
1309  addr[i].default_server = cscf;
1310  }
1311 
1312  addr[i].opt.default_server = default_server;
1313 #if (NGX_HTTP_SSL)
1314  addr[i].opt.ssl = ssl;
1315 #endif
1316 #if (NGX_HTTP_SPDY)
1317  addr[i].opt.spdy = spdy;
1318 #endif
1319 
1320  return NGX_OK;
1321  }
1322 
1323  /* add the address to the addresses list that bound to this port */
1324 
1325  return ngx_http_add_address(cf, cscf, port, lsopt);
1326 }
1327 
1328 
1329 /*
1330  * add the server address, the server names and the server core module
1331  * configurations to the port list
1332  */
1333 
1334 static ngx_int_t
1335 ngx_http_add_address(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1336  ngx_http_conf_port_t *port, ngx_http_listen_opt_t *lsopt)
1337 {
1338  ngx_http_conf_addr_t *addr;
1339 
1340  if (port->addrs.elts == NULL) {
1341  if (ngx_array_init(&port->addrs, cf->temp_pool, 4,
1342  sizeof(ngx_http_conf_addr_t))
1343  != NGX_OK)
1344  {
1345  return NGX_ERROR;
1346  }
1347  }
1348 
1349 #if (NGX_HTTP_SPDY && NGX_HTTP_SSL && !defined TLSEXT_TYPE_next_proto_neg)
1350  if (lsopt->spdy && lsopt->ssl) {
1351  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1352  "nginx was built without OpenSSL NPN support, "
1353  "SPDY is not enabled for %s", lsopt->addr);
1354  }
1355 #endif
1356 
1357  addr = ngx_array_push(&port->addrs);
1358  if (addr == NULL) {
1359  return NGX_ERROR;
1360  }
1361 
1362  addr->opt = *lsopt;
1363  addr->hash.buckets = NULL;
1364  addr->hash.size = 0;
1365  addr->wc_head = NULL;
1366  addr->wc_tail = NULL;
1367 #if (NGX_PCRE)
1368  addr->nregex = 0;
1369  addr->regex = NULL;
1370 #endif
1371  addr->default_server = cscf;
1372  addr->servers.elts = NULL;
1373 
1374  return ngx_http_add_server(cf, cscf, addr);
1375 }
1376 
1377 
1378 /* add the server core module configuration to the address:port */
1379 
1380 static ngx_int_t
1381 ngx_http_add_server(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
1382  ngx_http_conf_addr_t *addr)
1383 {
1384  ngx_uint_t i;
1385  ngx_http_core_srv_conf_t **server;
1386 
1387  if (addr->servers.elts == NULL) {
1388  if (ngx_array_init(&addr->servers, cf->temp_pool, 4,
1389  sizeof(ngx_http_core_srv_conf_t *))
1390  != NGX_OK)
1391  {
1392  return NGX_ERROR;
1393  }
1394 
1395  } else {
1396  server = addr->servers.elts;
1397  for (i = 0; i < addr->servers.nelts; i++) {
1398  if (server[i] == cscf) {
1399  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1400  "a duplicate listen %s", addr->opt.addr);
1401  return NGX_ERROR;
1402  }
1403  }
1404  }
1405 
1406  server = ngx_array_push(&addr->servers);
1407  if (server == NULL) {
1408  return NGX_ERROR;
1409  }
1410 
1411  *server = cscf;
1412 
1413  return NGX_OK;
1414 }
1415 
1416 
1417 static ngx_int_t
1418 ngx_http_optimize_servers(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
1419  ngx_array_t *ports)
1420 {
1421  ngx_uint_t p, a;
1422  ngx_http_conf_port_t *port;
1423  ngx_http_conf_addr_t *addr;
1424 
1425  if (ports == NULL) {
1426  return NGX_OK;
1427  }
1428 
1429  port = ports->elts;
1430  for (p = 0; p < ports->nelts; p++) {
1431 
1432  ngx_sort(port[p].addrs.elts, (size_t) port[p].addrs.nelts,
1433  sizeof(ngx_http_conf_addr_t), ngx_http_cmp_conf_addrs);
1434 
1435  /*
1436  * check whether all name-based servers have the same
1437  * configuration as a default server for given address:port
1438  */
1439 
1440  addr = port[p].addrs.elts;
1441  for (a = 0; a < port[p].addrs.nelts; a++) {
1442 
1443  if (addr[a].servers.nelts > 1
1444 #if (NGX_PCRE)
1445  || addr[a].default_server->captures
1446 #endif
1447  )
1448  {
1449  if (ngx_http_server_names(cf, cmcf, &addr[a]) != NGX_OK) {
1450  return NGX_ERROR;
1451  }
1452  }
1453  }
1454 
1455  if (ngx_http_init_listening(cf, &port[p]) != NGX_OK) {
1456  return NGX_ERROR;
1457  }
1458  }
1459 
1460  return NGX_OK;
1461 }
1462 
1463 
1464 static ngx_int_t
1465 ngx_http_server_names(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
1466  ngx_http_conf_addr_t *addr)
1467 {
1468  ngx_int_t rc;
1469  ngx_uint_t n, s;
1470  ngx_hash_init_t hash;
1471  ngx_hash_keys_arrays_t ha;
1472  ngx_http_server_name_t *name;
1473  ngx_http_core_srv_conf_t **cscfp;
1474 #if (NGX_PCRE)
1475  ngx_uint_t regex, i;
1476 
1477  regex = 0;
1478 #endif
1479 
1480  ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t));
1481 
1482  ha.temp_pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
1483  if (ha.temp_pool == NULL) {
1484  return NGX_ERROR;
1485  }
1486 
1487  ha.pool = cf->pool;
1488 
1489  if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) {
1490  goto failed;
1491  }
1492 
1493  cscfp = addr->servers.elts;
1494 
1495  for (s = 0; s < addr->servers.nelts; s++) {
1496 
1497  name = cscfp[s]->server_names.elts;
1498 
1499  for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
1500 
1501 #if (NGX_PCRE)
1502  if (name[n].regex) {
1503  regex++;
1504  continue;
1505  }
1506 #endif
1507 
1508  rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,
1509  NGX_HASH_WILDCARD_KEY);
1510 
1511  if (rc == NGX_ERROR) {
1512  return NGX_ERROR;
1513  }
1514 
1515  if (rc == NGX_DECLINED) {
1516  ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
1517  "invalid server name or wildcard \"%V\" on %s",
1518  &name[n].name, addr->opt.addr);
1519  return NGX_ERROR;
1520  }
1521 
1522  if (rc == NGX_BUSY) {
1523  ngx_log_error(NGX_LOG_WARN, cf->log, 0,
1524  "conflicting server name \"%V\" on %s, ignored",
1525  &name[n].name, addr->opt.addr);
1526  }
1527  }
1528  }
1529 
1530  hash.key = ngx_hash_key_lc;
1531  hash.max_size = cmcf->server_names_hash_max_size;
1532  hash.bucket_size = cmcf->server_names_hash_bucket_size;
1533  hash.name = "server_names_hash";
1534  hash.pool = cf->pool;
1535 
1536  if (ha.keys.nelts) {
1537  hash.hash = &addr->hash;
1538  hash.temp_pool = NULL;
1539 
1540  if (ngx_hash_init(&hash, ha.keys.elts, ha.keys.nelts) != NGX_OK) {
1541  goto failed;
1542  }
1543  }
1544 
1545  if (ha.dns_wc_head.nelts) {
1546 
1547  ngx_qsort(ha.dns_wc_head.elts, (size_t) ha.dns_wc_head.nelts,
1548  sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
1549 
1550  hash.hash = NULL;
1551  hash.temp_pool = ha.temp_pool;
1552 
1553  if (ngx_hash_wildcard_init(&hash, ha.dns_wc_head.elts,
1554  ha.dns_wc_head.nelts)
1555  != NGX_OK)
1556  {
1557  goto failed;
1558  }
1559 
1560  addr->wc_head = (ngx_hash_wildcard_t *) hash.hash;
1561  }
1562 
1563  if (ha.dns_wc_tail.nelts) {
1564 
1565  ngx_qsort(ha.dns_wc_tail.elts, (size_t) ha.dns_wc_tail.nelts,
1566  sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
1567 
1568  hash.hash = NULL;
1569  hash.temp_pool = ha.temp_pool;
1570 
1571  if (ngx_hash_wildcard_init(&hash, ha.dns_wc_tail.elts,
1572  ha.dns_wc_tail.nelts)
1573  != NGX_OK)
1574  {
1575  goto failed;
1576  }
1577 
1578  addr->wc_tail = (ngx_hash_wildcard_t *) hash.hash;
1579  }
1580 
1581  ngx_destroy_pool(ha.temp_pool);
1582 
1583 #if (NGX_PCRE)
1584 
1585  if (regex == 0) {
1586  return NGX_OK;
1587  }
1588 
1589  addr->nregex = regex;
1590  addr->regex = ngx_palloc(cf->pool, regex * sizeof(ngx_http_server_name_t));
1591  if (addr->regex == NULL) {
1592  return NGX_ERROR;
1593  }
1594 
1595  i = 0;
1596 
1597  for (s = 0; s < addr->servers.nelts; s++) {
1598 
1599  name = cscfp[s]->server_names.elts;
1600 
1601  for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
1602  if (name[n].regex) {
1603  addr->regex[i++] = name[n];
1604  }
1605  }
1606  }
1607 
1608 #endif
1609 
1610  return NGX_OK;
1611 
1612 failed:
1613 
1614  ngx_destroy_pool(ha.temp_pool);
1615 
1616  return NGX_ERROR;
1617 }
1618 
1619 
1620 static ngx_int_t
1621 ngx_http_cmp_conf_addrs(const void *one, const void *two)
1622 {
1623  ngx_http_conf_addr_t *first, *second;
1624 
1625  first = (ngx_http_conf_addr_t *) one;
1626  second = (ngx_http_conf_addr_t *) two;
1627 
1628  if (first->opt.wildcard) {
1629  /* a wildcard address must be the last resort, shift it to the end */
1630  return 1;
1631  }
1632 
1633  if (second->opt.wildcard) {
1634  /* a wildcard address must be the last resort, shift it to the end */
1635  return -1;
1636  }
1637 
1638  if (first->opt.bind && !second->opt.bind) {
1639  /* shift explicit bind()ed addresses to the start */
1640  return -1;
1641  }
1642 
1643  if (!first->opt.bind && second->opt.bind) {
1644  /* shift explicit bind()ed addresses to the start */
1645  return 1;
1646  }
1647 
1648  /* do not sort by default */
1649 
1650  return 0;
1651 }
1652 
1653 
1654 static int ngx_libc_cdecl
1655 ngx_http_cmp_dns_wildcards(const void *one, const void *two)
1656 {
1657  ngx_hash_key_t *first, *second;
1658 
1659  first = (ngx_hash_key_t *) one;
1660  second = (ngx_hash_key_t *) two;
1661 
1662  return ngx_dns_strcmp(first->key.data, second->key.data);
1663 }
1664 
1665 
1666 static ngx_int_t
1667 ngx_http_init_listening(ngx_conf_t *cf, ngx_http_conf_port_t *port)
1668 {
1669  ngx_uint_t i, last, bind_wildcard;
1670  ngx_listening_t *ls;
1671  ngx_http_port_t *hport;
1672  ngx_http_conf_addr_t *addr;
1673 
1674  addr = port->addrs.elts;
1675  last = port->addrs.nelts;
1676 
1677  /*
1678  * If there is a binding to an "*:port" then we need to bind() to
1679  * the "*:port" only and ignore other implicit bindings. The bindings
1680  * have been already sorted: explicit bindings are on the start, then
1681  * implicit bindings go, and wildcard binding is in the end.
1682  */
1683 
1684  if (addr[last - 1].opt.wildcard) {
1685  addr[last - 1].opt.bind = 1;
1686  bind_wildcard = 1;
1687 
1688  } else {
1689  bind_wildcard = 0;
1690  }
1691 
1692  i = 0;
1693 
1694  while (i < last) {
1695 
1696  if (bind_wildcard && !addr[i].opt.bind) {
1697  i++;
1698  continue;
1699  }
1700 
1701  ls = ngx_http_add_listening(cf, &addr[i]);
1702  if (ls == NULL) {
1703  return NGX_ERROR;
1704  }
1705 
1706  hport = ngx_pcalloc(cf->pool, sizeof(ngx_http_port_t));
1707  if (hport == NULL) {
1708  return NGX_ERROR;
1709  }
1710 
1711  ls->servers = hport;
1712 
1713  if (i == last - 1) {
1714  hport->naddrs = last;
1715 
1716  } else {
1717  hport->naddrs = 1;
1718  i = 0;
1719  }
1720 
1721  switch (ls->sockaddr->sa_family) {
1722 
1723 #if (NGX_HAVE_INET6)
1724  case AF_INET6:
1725  if (ngx_http_add_addrs6(cf, hport, addr) != NGX_OK) {
1726  return NGX_ERROR;
1727  }
1728  break;
1729 #endif
1730  default: /* AF_INET */
1731  if (ngx_http_add_addrs(cf, hport, addr) != NGX_OK) {
1732  return NGX_ERROR;
1733  }
1734  break;
1735  }
1736 
1737  addr++;
1738  last--;
1739  }
1740 
1741  return NGX_OK;
1742 }
1743 
1744 
1745 static ngx_listening_t *
1746 ngx_http_add_listening(ngx_conf_t *cf, ngx_http_conf_addr_t *addr)
1747 {
1748  ngx_listening_t *ls;
1749  ngx_http_core_loc_conf_t *clcf;
1750  ngx_http_core_srv_conf_t *cscf;
1751 
1752  ls = ngx_create_listening(cf, &addr->opt.u.sockaddr, addr->opt.socklen);
1753  if (ls == NULL) {
1754  return NULL;
1755  }
1756 
1757  ls->addr_ntop = 1;
1758 
1759  ls->handler = ngx_http_init_connection;
1760 
1761  cscf = addr->default_server;
1762  ls->pool_size = cscf->connection_pool_size;
1763  ls->post_accept_timeout = cscf->client_header_timeout;
1764 
1765  clcf = cscf->ctx->loc_conf[ngx_http_core_module.ctx_index];
1766 
1767  ls->logp = clcf->error_log;
1768  ls->log.data = &ls->addr_text;
1769  ls->log.handler = ngx_accept_log_error;
1770 
1771 #if (NGX_WIN32)
1772  {
1773  ngx_iocp_conf_t *iocpcf = NULL;
1774 
1775  if (ngx_get_conf(cf->cycle->conf_ctx, ngx_events_module)) {
1776  iocpcf = ngx_event_get_conf(cf->cycle->conf_ctx, ngx_iocp_module);
1777  }
1778  if (iocpcf && iocpcf->acceptex_read) {
1779  ls->post_accept_buffer_size = cscf->client_header_buffer_size;
1780  }
1781  }
1782 #endif
1783 
1784  ls->backlog = addr->opt.backlog;
1785  ls->rcvbuf = addr->opt.rcvbuf;
1786  ls->sndbuf = addr->opt.sndbuf;
1787 
1788  ls->keepalive = addr->opt.so_keepalive;
1789 #if (NGX_HAVE_KEEPALIVE_TUNABLE)
1790  ls->keepidle = addr->opt.tcp_keepidle;
1791  ls->keepintvl = addr->opt.tcp_keepintvl;
1792  ls->keepcnt = addr->opt.tcp_keepcnt;
1793 #endif
1794 
1795 #if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)
1796  ls->accept_filter = addr->opt.accept_filter;
1797 #endif
1798 
1799 #if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)
1800  ls->deferred_accept = addr->opt.deferred_accept;
1801 #endif
1802 
1803 #if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
1804  ls->ipv6only = addr->opt.ipv6only;
1805 #endif
1806 
1807 #if (NGX_HAVE_SETFIB)
1808  ls->setfib = addr->opt.setfib;
1809 #endif
1810 
1811  return ls;
1812 }
1813 
1814 
1815 static ngx_int_t
1816 ngx_http_add_addrs(ngx_conf_t *cf, ngx_http_port_t *hport,
1817  ngx_http_conf_addr_t *addr)
1818 {
1819  ngx_uint_t i;
1820  ngx_http_in_addr_t *addrs;
1821  struct sockaddr_in *sin;
1822  ngx_http_virtual_names_t *vn;
1823 
1824  hport->addrs = ngx_pcalloc(cf->pool,
1825  hport->naddrs * sizeof(ngx_http_in_addr_t));
1826  if (hport->addrs == NULL) {
1827  return NGX_ERROR;
1828  }
1829 
1830  addrs = hport->addrs;
1831 
1832  for (i = 0; i < hport->naddrs; i++) {
1833 
1834  sin = &addr[i].opt.u.sockaddr_in;
1835  addrs[i].addr = sin->sin_addr.s_addr;
1836  addrs[i].conf.default_server = addr[i].default_server;
1837 #if (NGX_HTTP_SSL)
1838  addrs[i].conf.ssl = addr[i].opt.ssl;
1839 #endif
1840 #if (NGX_HTTP_SPDY)
1841  addrs[i].conf.spdy = addr[i].opt.spdy;
1842 #endif
1843 
1844  if (addr[i].hash.buckets == NULL
1845  && (addr[i].wc_head == NULL
1846  || addr[i].wc_head->hash.buckets == NULL)
1847  && (addr[i].wc_tail == NULL
1848  || addr[i].wc_tail->hash.buckets == NULL)
1849 #if (NGX_PCRE)
1850  && addr[i].nregex == 0
1851 #endif
1852  )
1853  {
1854  continue;
1855  }
1856 
1857  vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t));
1858  if (vn == NULL) {
1859  return NGX_ERROR;
1860  }
1861 
1862  addrs[i].conf.virtual_names = vn;
1863 
1864  vn->names.hash = addr[i].hash;
1865  vn->names.wc_head = addr[i].wc_head;
1866  vn->names.wc_tail = addr[i].wc_tail;
1867 #if (NGX_PCRE)
1868  vn->nregex = addr[i].nregex;
1869  vn->regex = addr[i].regex;
1870 #endif
1871  }
1872 
1873  return NGX_OK;
1874 }
1875 
1876 
1877 #if (NGX_HAVE_INET6)
1878 
1879 static ngx_int_t
1880 ngx_http_add_addrs6(ngx_conf_t *cf, ngx_http_port_t *hport,
1881  ngx_http_conf_addr_t *addr)
1882 {
1883  ngx_uint_t i;
1884  ngx_http_in6_addr_t *addrs6;
1885  struct sockaddr_in6 *sin6;
1886  ngx_http_virtual_names_t *vn;
1887 
1888  hport->addrs = ngx_pcalloc(cf->pool,
1889  hport->naddrs * sizeof(ngx_http_in6_addr_t));
1890  if (hport->addrs == NULL) {
1891  return NGX_ERROR;
1892  }
1893 
1894  addrs6 = hport->addrs;
1895 
1896  for (i = 0; i < hport->naddrs; i++) {
1897 
1898  sin6 = &addr[i].opt.u.sockaddr_in6;
1899  addrs6[i].addr6 = sin6->sin6_addr;
1900  addrs6[i].conf.default_server = addr[i].default_server;
1901 #if (NGX_HTTP_SSL)
1902  addrs6[i].conf.ssl = addr[i].opt.ssl;
1903 #endif
1904 #if (NGX_HTTP_SPDY)
1905  addrs6[i].conf.spdy = addr[i].opt.spdy;
1906 #endif
1907 
1908  if (addr[i].hash.buckets == NULL
1909  && (addr[i].wc_head == NULL
1910  || addr[i].wc_head->hash.buckets == NULL)
1911  && (addr[i].wc_tail == NULL
1912  || addr[i].wc_tail->hash.buckets == NULL)
1913 #if (NGX_PCRE)
1914  && addr[i].nregex == 0
1915 #endif
1916  )
1917  {
1918  continue;
1919  }
1920 
1921  vn = ngx_palloc(cf->pool, sizeof(ngx_http_virtual_names_t));
1922  if (vn == NULL) {
1923  return NGX_ERROR;
1924  }
1925 
1926  addrs6[i].conf.virtual_names = vn;
1927 
1928  vn->names.hash = addr[i].hash;
1929  vn->names.wc_head = addr[i].wc_head;
1930  vn->names.wc_tail = addr[i].wc_tail;
1931 #if (NGX_PCRE)
1932  vn->nregex = addr[i].nregex;
1933  vn->regex = addr[i].regex;
1934 #endif
1935  }
1936 
1937  return NGX_OK;
1938 }
1939 
1940 #endif
1941 
1942 
1943 char *
1944 ngx_http_types_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1945 {
1946  char *p = conf;
1947 
1948  ngx_array_t **types;
1949  ngx_str_t *value, *default_type;
1950  ngx_uint_t i, n, hash;
1951  ngx_hash_key_t *type;
1952 
1953  types = (ngx_array_t **) (p + cmd->offset);
1954 
1955  if (*types == (void *) -1) {
1956  return NGX_CONF_OK;
1957  }
1958 
1959  default_type = cmd->post;
1960 
1961  if (*types == NULL) {
1962  *types = ngx_array_create(cf->temp_pool, 1, sizeof(ngx_hash_key_t));
1963  if (*types == NULL) {
1964  return NGX_CONF_ERROR;
1965  }
1966 
1967  if (default_type) {
1968  type = ngx_array_push(*types);
1969  if (type == NULL) {
1970  return NGX_CONF_ERROR;
1971  }
1972 
1973  type->key = *default_type;
1974  type->key_hash = ngx_hash_key(default_type->data,
1975  default_type->len);
1976  type->value = (void *) 4;
1977  }
1978  }
1979 
1980  value = cf->args->elts;
1981 
1982  for (i = 1; i < cf->args->nelts; i++) {
1983 
1984  if (value[i].len == 1 && value[i].data[0] == '*') {
1985  *types = (void *) -1;
1986  return NGX_CONF_OK;
1987  }
1988 
1989  hash = ngx_hash_strlow(value[i].data, value[i].data, value[i].len);
1990  value[i].data[value[i].len] = '\0';
1991 
1992  type = (*types)->elts;
1993  for (n = 0; n < (*types)->nelts; n++) {
1994 
1995  if (ngx_strcmp(value[i].data, type[n].key.data) == 0) {
1996  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1997  "duplicate MIME type \"%V\"", &value[i]);
1998  continue;
1999  }
2000  }
2001 
2002  type = ngx_array_push(*types);
2003  if (type == NULL) {
2004  return NGX_CONF_ERROR;
2005  }
2006 
2007  type->key = value[i];
2008  type->key_hash = hash;
2009  type->value = (void *) 4;
2010  }
2011 
2012  return NGX_CONF_OK;
2013 }
2014 
2015 
2016 char *
2017 ngx_http_merge_types(ngx_conf_t *cf, ngx_array_t **keys, ngx_hash_t *types_hash,
2018  ngx_array_t **prev_keys, ngx_hash_t *prev_types_hash,
2019  ngx_str_t *default_types)
2020 {
2021  ngx_hash_init_t hash;
2022 
2023  if (*keys) {
2024 
2025  if (*keys == (void *) -1) {
2026  return NGX_CONF_OK;
2027  }
2028 
2029  hash.hash = types_hash;
2030  hash.key = NULL;
2031  hash.max_size = 2048;
2032  hash.bucket_size = 64;
2033  hash.name = "test_types_hash";
2034  hash.pool = cf->pool;
2035  hash.temp_pool = NULL;
2036 
2037  if (ngx_hash_init(&hash, (*keys)->elts, (*keys)->nelts) != NGX_OK) {
2038  return NGX_CONF_ERROR;
2039  }
2040 
2041  return NGX_CONF_OK;
2042  }
2043 
2044  if (prev_types_hash->buckets == NULL) {
2045 
2046  if (*prev_keys == NULL) {
2047 
2048  if (ngx_http_set_default_types(cf, prev_keys, default_types)
2049  != NGX_OK)
2050  {
2051  return NGX_CONF_ERROR;
2052  }
2053 
2054  } else if (*prev_keys == (void *) -1) {
2055  *keys = *prev_keys;
2056  return NGX_CONF_OK;
2057  }
2058 
2059  hash.hash = prev_types_hash;
2060  hash.key = NULL;
2061  hash.max_size = 2048;
2062  hash.bucket_size = 64;
2063  hash.name = "test_types_hash";
2064  hash.pool = cf->pool;
2065  hash.temp_pool = NULL;
2066 
2067  if (ngx_hash_init(&hash, (*prev_keys)->elts, (*prev_keys)->nelts)
2068  != NGX_OK)
2069  {
2070  return NGX_CONF_ERROR;
2071  }
2072  }
2073 
2074  *types_hash = *prev_types_hash;
2075 
2076  return NGX_CONF_OK;
2077 
2078 }
2079 
2080 
2081 ngx_int_t
2082 ngx_http_set_default_types(ngx_conf_t *cf, ngx_array_t **types,
2083  ngx_str_t *default_type)
2084 {
2085  ngx_hash_key_t *type;
2086 
2087  *types = ngx_array_create(cf->temp_pool, 1, sizeof(ngx_hash_key_t));
2088  if (*types == NULL) {
2089  return NGX_ERROR;
2090  }
2091 
2092  while (default_type->len) {
2093 
2094  type = ngx_array_push(*types);
2095  if (type == NULL) {
2096  return NGX_ERROR;
2097  }
2098 
2099  type->key = *default_type;
2100  type->key_hash = ngx_hash_key(default_type->data,
2101  default_type->len);
2102  type->value = (void *) 4;
2103 
2104  default_type++;
2105  }
2106 
2107  return NGX_OK;
2108 }
Generated on Sun Nov 10 2013 09:49:08 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2