0
|
1
|
|
2 /*
|
|
3 * Copyright (C) Igor Sysoev
|
|
4 */
|
|
5
|
|
6
|
|
7 #include <ngx_config.h>
|
|
8 #include <ngx_core.h>
|
|
9 #include <ngx_event.h>
|
|
10 #include <ngx_http.h>
|
|
11
|
|
12
|
|
13 static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
|
4
|
14 static ngx_int_t ngx_http_add_address(ngx_conf_t *cf,
|
|
15 ngx_http_in_port_t *in_port,
|
|
16 ngx_http_listen_t *lscf,
|
|
17 ngx_http_core_srv_conf_t *cscf);
|
|
18 static ngx_int_t ngx_http_add_names(ngx_conf_t *cf,
|
|
19 ngx_http_in_addr_t *in_addr,
|
|
20 ngx_http_core_srv_conf_t *cscf);
|
|
21
|
0
|
22 static char *ngx_http_merge_locations(ngx_conf_t *cf,
|
|
23 ngx_array_t *locations,
|
|
24 void **loc_conf,
|
|
25 ngx_http_module_t *module,
|
|
26 ngx_uint_t ctx_index);
|
|
27
|
|
28 int ngx_http_max_module;
|
|
29
|
|
30 ngx_uint_t ngx_http_total_requests;
|
|
31 uint64_t ngx_http_total_sent;
|
|
32
|
|
33
|
|
34 ngx_int_t (*ngx_http_top_header_filter) (ngx_http_request_t *r);
|
|
35 ngx_int_t (*ngx_http_top_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch);
|
|
36
|
|
37
|
|
38 static ngx_command_t ngx_http_commands[] = {
|
|
39
|
|
40 {ngx_string("http"),
|
|
41 NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
|
|
42 ngx_http_block,
|
|
43 0,
|
|
44 0,
|
|
45 NULL},
|
|
46
|
|
47 ngx_null_command
|
|
48 };
|
|
49
|
|
50
|
|
51 static ngx_core_module_t ngx_http_module_ctx = {
|
|
52 ngx_string("http"),
|
|
53 NULL,
|
|
54 NULL
|
|
55 };
|
|
56
|
|
57
|
|
58 ngx_module_t ngx_http_module = {
|
|
59 NGX_MODULE,
|
|
60 &ngx_http_module_ctx, /* module context */
|
|
61 ngx_http_commands, /* module directives */
|
|
62 NGX_CORE_MODULE, /* module type */
|
|
63 NULL, /* init module */
|
|
64 NULL /* init child */
|
|
65 };
|
|
66
|
|
67
|
|
68 static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
|
|
69 {
|
|
70 char *rv;
|
|
71 ngx_uint_t mi, m, s, l, p, a, n;
|
|
72 ngx_uint_t port_found, addr_found, virtual_names;
|
|
73 ngx_conf_t pcf;
|
|
74 ngx_array_t in_ports;
|
|
75 ngx_listening_t *ls;
|
|
76 ngx_http_listen_t *lscf;
|
|
77 ngx_http_module_t *module;
|
|
78 ngx_http_handler_pt *h;
|
|
79 ngx_http_conf_ctx_t *ctx;
|
|
80 ngx_http_in_port_t *in_port, *inport;
|
|
81 ngx_http_in_addr_t *in_addr, *inaddr;
|
|
82 ngx_http_server_name_t *s_name, *name;
|
|
83 ngx_http_core_srv_conf_t **cscfp, *cscf;
|
|
84 ngx_http_core_loc_conf_t *clcf;
|
|
85 ngx_http_core_main_conf_t *cmcf;
|
|
86 #if (WIN32)
|
|
87 ngx_iocp_conf_t *iocpcf;
|
|
88 #endif
|
|
89
|
4
|
90 #if (NGX_SUPPRESS_WARN)
|
|
91 /* MSVC thinks 'in_ports' may be used without having been initialized */
|
|
92 ngx_memzero(&in_ports, sizeof(ngx_array_t));
|
|
93 #endif
|
|
94
|
0
|
95 /* the main http context */
|
|
96 ngx_test_null(ctx,
|
|
97 ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)),
|
|
98 NGX_CONF_ERROR);
|
|
99
|
|
100 *(ngx_http_conf_ctx_t **) conf = ctx;
|
|
101
|
|
102 /* count the number of the http modules and set up their indices */
|
|
103
|
|
104 ngx_http_max_module = 0;
|
|
105 for (m = 0; ngx_modules[m]; m++) {
|
|
106 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
|
|
107 continue;
|
|
108 }
|
|
109
|
|
110 ngx_modules[m]->ctx_index = ngx_http_max_module++;
|
|
111 }
|
|
112
|
|
113 /* the main http main_conf, it's the same in the all http contexts */
|
|
114 ngx_test_null(ctx->main_conf,
|
|
115 ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
|
|
116 NGX_CONF_ERROR);
|
|
117
|
|
118 /* the http null srv_conf, it's used to merge the server{}s' srv_conf's */
|
|
119 ngx_test_null(ctx->srv_conf,
|
|
120 ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
|
|
121 NGX_CONF_ERROR);
|
|
122
|
|
123 /* the http null loc_conf, it's used to merge the server{}s' loc_conf's */
|
|
124 ngx_test_null(ctx->loc_conf,
|
|
125 ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
|
|
126 NGX_CONF_ERROR);
|
|
127
|
|
128
|
|
129 /* create the main_conf, srv_conf and loc_conf in all http modules */
|
|
130
|
|
131 for (m = 0; ngx_modules[m]; m++) {
|
|
132 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
|
|
133 continue;
|
|
134 }
|
|
135
|
|
136 module = ngx_modules[m]->ctx;
|
|
137 mi = ngx_modules[m]->ctx_index;
|
|
138
|
|
139 if (module->pre_conf) {
|
|
140 if (module->pre_conf(cf) != NGX_OK) {
|
|
141 return NGX_CONF_ERROR;
|
|
142 }
|
|
143 }
|
|
144
|
|
145 if (module->create_main_conf) {
|
|
146 ngx_test_null(ctx->main_conf[mi], module->create_main_conf(cf),
|
|
147 NGX_CONF_ERROR);
|
|
148 }
|
|
149
|
|
150 if (module->create_srv_conf) {
|
|
151 ngx_test_null(ctx->srv_conf[mi], module->create_srv_conf(cf),
|
|
152 NGX_CONF_ERROR);
|
|
153 }
|
|
154
|
|
155 if (module->create_loc_conf) {
|
|
156 ngx_test_null(ctx->loc_conf[mi], module->create_loc_conf(cf),
|
|
157 NGX_CONF_ERROR);
|
|
158 }
|
|
159 }
|
|
160
|
|
161 /* parse inside the http{} block */
|
|
162
|
|
163 pcf = *cf;
|
|
164 cf->ctx = ctx;
|
|
165 cf->module_type = NGX_HTTP_MODULE;
|
|
166 cf->cmd_type = NGX_HTTP_MAIN_CONF;
|
|
167 rv = ngx_conf_parse(cf, NULL);
|
|
168
|
|
169 if (rv != NGX_CONF_OK) {
|
|
170 *cf = pcf;
|
|
171 return rv;
|
|
172 }
|
|
173
|
|
174 /*
|
|
175 * init http{} main_conf's, merge the server{}s' srv_conf's
|
|
176 * and its location{}s' loc_conf's
|
|
177 */
|
|
178
|
|
179 cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
|
|
180 cscfp = cmcf->servers.elts;
|
|
181
|
|
182 for (m = 0; ngx_modules[m]; m++) {
|
|
183 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
|
|
184 continue;
|
|
185 }
|
|
186
|
|
187 module = ngx_modules[m]->ctx;
|
|
188 mi = ngx_modules[m]->ctx_index;
|
|
189
|
|
190 /* init http{} main_conf's */
|
|
191
|
|
192 if (module->init_main_conf) {
|
|
193 rv = module->init_main_conf(cf, ctx->main_conf[mi]);
|
|
194 if (rv != NGX_CONF_OK) {
|
|
195 *cf = pcf;
|
|
196 return rv;
|
|
197 }
|
|
198 }
|
|
199
|
|
200 for (s = 0; s < cmcf->servers.nelts; s++) {
|
|
201
|
|
202 /* merge the server{}s' srv_conf's */
|
|
203
|
|
204 if (module->merge_srv_conf) {
|
|
205 rv = module->merge_srv_conf(cf,
|
|
206 ctx->srv_conf[mi],
|
|
207 cscfp[s]->ctx->srv_conf[mi]);
|
|
208 if (rv != NGX_CONF_OK) {
|
|
209 *cf = pcf;
|
|
210 return rv;
|
|
211 }
|
|
212 }
|
|
213
|
|
214 if (module->merge_loc_conf) {
|
|
215
|
|
216 /* merge the server{}'s loc_conf */
|
|
217
|
|
218 rv = module->merge_loc_conf(cf,
|
|
219 ctx->loc_conf[mi],
|
|
220 cscfp[s]->ctx->loc_conf[mi]);
|
|
221 if (rv != NGX_CONF_OK) {
|
|
222 *cf = pcf;
|
|
223 return rv;
|
|
224 }
|
|
225
|
|
226 /* merge the locations{}' loc_conf's */
|
|
227
|
|
228 rv = ngx_http_merge_locations(cf, &cscfp[s]->locations,
|
|
229 cscfp[s]->ctx->loc_conf,
|
|
230 module, mi);
|
|
231 if (rv != NGX_CONF_OK) {
|
|
232 *cf = pcf;
|
|
233 return rv;
|
|
234 }
|
|
235
|
|
236 #if 0
|
|
237 clcfp = (ngx_http_core_loc_conf_t **) cscfp[s]->locations.elts;
|
|
238
|
|
239 for (l = 0; l < cscfp[s]->locations.nelts; l++) {
|
|
240 rv = module->merge_loc_conf(cf,
|
|
241 cscfp[s]->ctx->loc_conf[mi],
|
|
242 clcfp[l]->loc_conf[mi]);
|
|
243 if (rv != NGX_CONF_OK) {
|
|
244 *cf = pcf;
|
|
245 return rv;
|
|
246 }
|
|
247 }
|
|
248 #endif
|
|
249 }
|
|
250 }
|
|
251 }
|
|
252
|
|
253 /* we needed "http"'s cf->ctx while merging configuration */
|
|
254 *cf = pcf;
|
|
255
|
|
256 /* init lists of the handlers */
|
|
257
|
|
258 ngx_init_array(cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers,
|
|
259 cf->cycle->pool, 10, sizeof(ngx_http_handler_pt),
|
|
260 NGX_CONF_ERROR);
|
|
261 cmcf->phases[NGX_HTTP_REWRITE_PHASE].type = NGX_OK;
|
|
262
|
|
263
|
|
264 /* the special find config phase for single handler */
|
|
265
|
|
266 ngx_init_array(cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers,
|
|
267 cf->cycle->pool, 1, sizeof(ngx_http_handler_pt),
|
|
268 NGX_CONF_ERROR);
|
|
269 cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].type = NGX_OK;
|
|
270
|
|
271 ngx_test_null(h, ngx_push_array(
|
|
272 &cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers),
|
|
273 NGX_CONF_ERROR);
|
|
274 *h = ngx_http_find_location_config;
|
|
275
|
|
276
|
|
277 ngx_init_array(cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers,
|
|
278 cf->cycle->pool, 10, sizeof(ngx_http_handler_pt),
|
|
279 NGX_CONF_ERROR);
|
|
280 cmcf->phases[NGX_HTTP_ACCESS_PHASE].type = NGX_DECLINED;
|
|
281
|
|
282
|
|
283 ngx_init_array(cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers,
|
|
284 cf->cycle->pool, 10, sizeof(ngx_http_handler_pt),
|
|
285 NGX_CONF_ERROR);
|
|
286 cmcf->phases[NGX_HTTP_CONTENT_PHASE].type = NGX_OK;
|
|
287
|
|
288
|
|
289 /*
|
4
|
290 * create the lists of ports, addresses and server names
|
|
291 * to quickly find the server core module configuration at run-time
|
0
|
292 */
|
|
293
|
4
|
294 if (ngx_array_init(&in_ports, cf->pool, 10, sizeof(ngx_http_in_port_t))
|
|
295 == NGX_ERROR)
|
|
296 {
|
|
297 return NGX_CONF_ERROR;
|
|
298 }
|
0
|
299
|
|
300 /* "server" directives */
|
4
|
301
|
0
|
302 cscfp = cmcf->servers.elts;
|
|
303 for (s = 0; s < cmcf->servers.nelts; s++) {
|
|
304
|
|
305 /* "listen" directives */
|
4
|
306
|
0
|
307 lscf = cscfp[s]->listen.elts;
|
|
308 for (l = 0; l < cscfp[s]->listen.nelts; l++) {
|
|
309
|
|
310 port_found = 0;
|
|
311
|
|
312 /* AF_INET only */
|
|
313
|
|
314 in_port = in_ports.elts;
|
|
315 for (p = 0; p < in_ports.nelts; p++) {
|
|
316
|
|
317 if (lscf[l].port == in_port[p].port) {
|
|
318
|
|
319 /* the port is already in the port list */
|
|
320
|
|
321 port_found = 1;
|
|
322 addr_found = 0;
|
|
323
|
|
324 in_addr = in_port[p].addrs.elts;
|
|
325 for (a = 0; a < in_port[p].addrs.nelts; a++) {
|
|
326
|
|
327 if (lscf[l].addr == in_addr[a].addr) {
|
|
328
|
4
|
329 /* the address is already in the address list */
|
0
|
330
|
4
|
331 if (ngx_http_add_names(cf, &in_addr[a], cscfp[s])
|
|
332 == NGX_ERROR)
|
|
333 {
|
|
334 return NGX_CONF_ERROR;
|
0
|
335 }
|
|
336
|
|
337 /*
|
4
|
338 * check the duplicate "default" server
|
|
339 * for this address:port
|
0
|
340 */
|
|
341
|
|
342 if (lscf[l].default_server) {
|
4
|
343
|
0
|
344 if (in_addr[a].default_server) {
|
|
345 ngx_log_error(NGX_LOG_ERR, cf->log, 0,
|
4
|
346 "the duplicate default server in %s:%d",
|
|
347 lscf[l].file_name.data,
|
|
348 lscf[l].line);
|
0
|
349
|
|
350 return NGX_CONF_ERROR;
|
|
351 }
|
|
352
|
|
353 in_addr[a].core_srv_conf = cscfp[s];
|
|
354 in_addr[a].default_server = 1;
|
|
355 }
|
|
356
|
|
357 addr_found = 1;
|
|
358
|
|
359 break;
|
|
360
|
|
361 } else if (in_addr[a].addr == INADDR_ANY) {
|
|
362
|
4
|
363 /* the INADDR_ANY is always the last address */
|
|
364
|
|
365 if (!(inaddr = ngx_array_push(&in_port[p].addrs))) {
|
|
366 return NGX_CONF_ERROR;
|
|
367 }
|
|
368
|
0
|
369 /*
|
4
|
370 * the INADDR_ANY must be the last resort
|
|
371 * so we move it to the end of the address list
|
|
372 * and put the new address in its place
|
0
|
373 */
|
|
374
|
|
375 ngx_memcpy(inaddr, &in_addr[a],
|
|
376 sizeof(ngx_http_in_addr_t));
|
|
377
|
|
378 in_addr[a].addr = lscf[l].addr;
|
4
|
379 in_addr[a].names.elts = NULL;
|
0
|
380 in_addr[a].default_server = lscf[l].default_server;
|
|
381 in_addr[a].core_srv_conf = cscfp[s];
|
|
382
|
4
|
383 if (ngx_http_add_names(cf, &in_addr[a], cscfp[s])
|
|
384 == NGX_ERROR)
|
|
385 {
|
|
386 return NGX_CONF_ERROR;
|
|
387 }
|
0
|
388
|
|
389 addr_found = 1;
|
|
390
|
|
391 break;
|
|
392 }
|
|
393 }
|
|
394
|
|
395 if (!addr_found) {
|
|
396
|
|
397 /*
|
|
398 * add the address to the addresses list that
|
|
399 * bound to this port
|
|
400 */
|
|
401
|
4
|
402 if (ngx_http_add_address(cf, &in_port[p], &lscf[l],
|
|
403 cscfp[s]) == NGX_ERROR)
|
|
404 {
|
|
405 return NGX_CONF_ERROR;
|
|
406 }
|
0
|
407 }
|
|
408 }
|
|
409 }
|
|
410
|
|
411 if (!port_found) {
|
|
412
|
|
413 /* add the port to the in_port list */
|
|
414
|
4
|
415 if (!(in_port = ngx_array_push(&in_ports))) {
|
|
416 return NGX_CONF_ERROR;
|
|
417 }
|
0
|
418
|
|
419 in_port->port = lscf[l].port;
|
4
|
420 in_port->addrs.elts = NULL;
|
0
|
421
|
4
|
422 if (!(in_port->port_text.data = ngx_palloc(cf->pool, 7))) {
|
|
423 return NGX_CONF_ERROR;
|
|
424 }
|
0
|
425
|
4
|
426 in_port->port_text.len = ngx_sprintf(in_port->port_text.data,
|
|
427 ":%d", in_port->port)
|
|
428 - in_port->port_text.data;
|
0
|
429
|
4
|
430 if (ngx_http_add_address(cf, in_port, &lscf[l], cscfp[s])
|
|
431 == NGX_ERROR)
|
|
432 {
|
|
433 return NGX_CONF_ERROR;
|
|
434 }
|
0
|
435 }
|
|
436 }
|
|
437 }
|
|
438
|
4
|
439
|
|
440 /* optimize the lists of ports, addresses and server names */
|
0
|
441
|
|
442 /* AF_INET only */
|
|
443
|
|
444 in_port = in_ports.elts;
|
|
445 for (p = 0; p < in_ports.nelts; p++) {
|
|
446
|
4
|
447 /*
|
|
448 * check whether all name-based servers have the same configuraiton
|
|
449 * as the default server, or some servers restrict the host names
|
|
450 */
|
0
|
451
|
|
452 in_addr = in_port[p].addrs.elts;
|
|
453 for (a = 0; a < in_port[p].addrs.nelts; a++) {
|
|
454
|
|
455 virtual_names = 0;
|
|
456
|
|
457 name = in_addr[a].names.elts;
|
|
458 for (n = 0; n < in_addr[a].names.nelts; n++) {
|
4
|
459 if (in_addr[a].core_srv_conf != name[n].core_srv_conf
|
|
460 || name[n].core_srv_conf->restrict_host_names
|
|
461 != NGX_HTTP_RESTRICT_HOST_OFF)
|
|
462 {
|
0
|
463 virtual_names = 1;
|
|
464 break;
|
|
465 }
|
|
466 }
|
|
467
|
|
468 /*
|
4
|
469 * if all name-based servers have the same configuration
|
|
470 * as the default server, and no servers restrict the host names
|
|
471 * then we do not need to check them at run-time at all
|
0
|
472 */
|
|
473
|
|
474 if (!virtual_names) {
|
|
475 in_addr[a].names.nelts = 0;
|
|
476 }
|
|
477 }
|
|
478
|
|
479 /*
|
|
480 * if there's the binding to "*:port" then we need to bind()
|
|
481 * to "*:port" only and ignore the other bindings
|
|
482 */
|
|
483
|
|
484 if (in_addr[a - 1].addr == INADDR_ANY) {
|
|
485 a--;
|
|
486
|
|
487 } else {
|
|
488 a = 0;
|
|
489 }
|
|
490
|
|
491 in_addr = in_port[p].addrs.elts;
|
|
492 while (a < in_port[p].addrs.nelts) {
|
|
493
|
|
494 ls = ngx_listening_inet_stream_socket(cf, in_addr[a].addr,
|
|
495 in_port[p].port);
|
|
496 if (ls == NULL) {
|
|
497 return NGX_CONF_ERROR;
|
|
498 }
|
|
499
|
|
500 ls->backlog = -1;
|
|
501 #if 0
|
|
502 #if 0
|
|
503 ls->nonblocking = 1;
|
|
504 #else
|
|
505 ls->nonblocking = 0;
|
|
506 #endif
|
|
507 #endif
|
|
508 ls->addr_ntop = 1;
|
|
509
|
|
510 ls->handler = ngx_http_init_connection;
|
|
511
|
|
512 cscf = in_addr[a].core_srv_conf;
|
|
513 ls->pool_size = cscf->connection_pool_size;
|
|
514 ls->post_accept_timeout = cscf->post_accept_timeout;
|
|
515
|
|
516 clcf = cscf->ctx->loc_conf[ngx_http_core_module.ctx_index];
|
|
517 ls->log = clcf->err_log;
|
|
518
|
|
519 #if (WIN32)
|
|
520 iocpcf = ngx_event_get_conf(cf->cycle->conf_ctx, ngx_iocp_module);
|
|
521 if (iocpcf->acceptex_read) {
|
|
522 ls->post_accept_buffer_size = cscf->client_header_buffer_size;
|
|
523 }
|
|
524 #endif
|
|
525
|
|
526 ls->ctx = ctx;
|
|
527
|
|
528 if (in_port[p].addrs.nelts > 1) {
|
|
529
|
|
530 in_addr = in_port[p].addrs.elts;
|
|
531 if (in_addr[in_port[p].addrs.nelts - 1].addr != INADDR_ANY) {
|
|
532
|
|
533 /*
|
|
534 * if this port has not the "*:port" binding then create
|
|
535 * the separate ngx_http_in_port_t for the all bindings
|
|
536 */
|
|
537
|
|
538 ngx_test_null(inport,
|
|
539 ngx_palloc(cf->pool,
|
|
540 sizeof(ngx_http_in_port_t)),
|
|
541 NGX_CONF_ERROR);
|
|
542
|
|
543 inport->port = in_port[p].port;
|
|
544 inport->port_text = in_port[p].port_text;
|
|
545
|
|
546 /* init list of the addresses ... */
|
|
547
|
|
548 ngx_init_array(inport->addrs, cf->pool, 1,
|
|
549 sizeof(ngx_http_in_addr_t),
|
|
550 NGX_CONF_ERROR);
|
|
551
|
|
552 /* ... and set up it with the first address */
|
|
553
|
|
554 inport->addrs.nelts = 1;
|
|
555 inport->addrs.elts = in_port[p].addrs.elts;
|
|
556
|
|
557 ls->servers = inport;
|
|
558
|
|
559 /* prepare for the next cycle */
|
|
560
|
|
561 in_port[p].addrs.elts = (char *) in_port[p].addrs.elts
|
|
562 + in_port[p].addrs.size;
|
|
563 in_port[p].addrs.nelts--;
|
|
564
|
|
565 in_addr = (ngx_http_in_addr_t *) in_port[p].addrs.elts;
|
|
566 a = 0;
|
|
567
|
|
568 continue;
|
|
569 }
|
|
570 }
|
|
571
|
|
572 ls->servers = &in_port[p];
|
|
573 a++;
|
|
574 }
|
|
575 }
|
|
576
|
|
577 #if (NGX_DEBUG)
|
4
|
578 {
|
|
579 u_char address[20];
|
|
580 ngx_uint_t p, a, n;
|
|
581
|
0
|
582 in_port = in_ports.elts;
|
|
583 for (p = 0; p < in_ports.nelts; p++) {
|
|
584 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
585 "port: %d %08x", in_port[p].port, &in_port[p]);
|
|
586 in_addr = in_port[p].addrs.elts;
|
|
587 for (a = 0; a < in_port[p].addrs.nelts; a++) {
|
4
|
588 ngx_inet_ntop(AF_INET, &in_addr[a].addr, address, 20);
|
|
589 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
590 "%s:%d %08x",
|
|
591 address, in_port[p].port, in_addr[a].core_srv_conf);
|
0
|
592 s_name = in_addr[a].names.elts;
|
|
593 for (n = 0; n < in_addr[a].names.nelts; n++) {
|
4
|
594 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
595 "%s:%d %s %08x",
|
|
596 address, in_port[p].port, s_name[n].name.data,
|
0
|
597 s_name[n].core_srv_conf);
|
|
598 }
|
|
599 }
|
|
600 }
|
4
|
601 }
|
0
|
602 #endif
|
|
603
|
|
604 return NGX_CONF_OK;
|
|
605 }
|
|
606
|
|
607
|
4
|
608 /*
|
|
609 * add the server address, the server names and the server core module
|
|
610 * configurations to the port (in_port)
|
|
611 */
|
|
612
|
|
613 static ngx_int_t ngx_http_add_address(ngx_conf_t *cf,
|
|
614 ngx_http_in_port_t *in_port,
|
|
615 ngx_http_listen_t *lscf,
|
|
616 ngx_http_core_srv_conf_t *cscf)
|
|
617 {
|
|
618 ngx_http_in_addr_t *in_addr;
|
|
619
|
|
620 if (in_port->addrs.elts == NULL) {
|
|
621 if (ngx_array_init(&in_port->addrs, cf->pool, 10,
|
|
622 sizeof(ngx_http_in_addr_t)) == NGX_ERROR)
|
|
623 {
|
|
624 return NGX_ERROR;
|
|
625 }
|
|
626 }
|
|
627
|
|
628 if (!(in_addr = ngx_array_push(&in_port->addrs))) {
|
|
629 return NGX_ERROR;
|
|
630 }
|
|
631
|
|
632 in_addr->addr = lscf->addr;
|
|
633 in_addr->names.elts = NULL;
|
|
634 in_addr->default_server = lscf->default_server;
|
|
635 in_addr->core_srv_conf = cscf;
|
|
636
|
|
637 #if (NGX_DEBUG)
|
|
638 {
|
|
639 u_char text[20];
|
|
640 ngx_inet_ntop(AF_INET, &in_addr->addr, text, 20);
|
|
641 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0, "address: %s:%d",
|
|
642 text, in_port->port);
|
|
643 }
|
|
644 #endif
|
|
645
|
|
646 return ngx_http_add_names(cf, in_addr, cscf);
|
|
647 }
|
|
648
|
|
649
|
|
650 /*
|
|
651 * add the server names and the server core module
|
|
652 * configurations to the address:port (in_addr)
|
|
653 */
|
|
654
|
|
655 static ngx_int_t ngx_http_add_names(ngx_conf_t *cf,
|
|
656 ngx_http_in_addr_t *in_addr,
|
|
657 ngx_http_core_srv_conf_t *cscf)
|
|
658 {
|
|
659 ngx_uint_t i;
|
|
660 ngx_http_server_name_t *server_names, *name;
|
|
661
|
|
662 if (in_addr->names.elts == NULL) {
|
|
663 if (ngx_array_init(&in_addr->names, cf->pool, 10,
|
|
664 sizeof(ngx_http_server_name_t)) == NGX_ERROR)
|
|
665 {
|
|
666 return NGX_ERROR;
|
|
667 }
|
|
668 }
|
|
669
|
|
670 server_names = cscf->server_names.elts;
|
|
671 for (i = 0; i < cscf->server_names.nelts; i++) {
|
|
672
|
|
673 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
674 "name: %s", server_names[i].name.data);
|
|
675
|
|
676 /* TODO: duplicate names can be checked here */
|
|
677
|
|
678 if (!(name = ngx_array_push(&in_addr->names))) {
|
|
679 return NGX_ERROR;
|
|
680 }
|
|
681
|
|
682 *name = server_names[i];
|
|
683 }
|
|
684
|
|
685 return NGX_OK;
|
|
686 }
|
|
687
|
|
688
|
0
|
689 static char *ngx_http_merge_locations(ngx_conf_t *cf,
|
|
690 ngx_array_t *locations,
|
|
691 void **loc_conf,
|
|
692 ngx_http_module_t *module,
|
|
693 ngx_uint_t ctx_index)
|
|
694 {
|
|
695 char *rv;
|
|
696 ngx_uint_t i;
|
|
697 ngx_http_core_loc_conf_t **clcfp;
|
|
698
|
|
699 clcfp = /* (ngx_http_core_loc_conf_t **) */ locations->elts;
|
|
700
|
|
701 for (i = 0; i < locations->nelts; i++) {
|
|
702 rv = module->merge_loc_conf(cf, loc_conf[ctx_index],
|
|
703 clcfp[i]->loc_conf[ctx_index]);
|
|
704 if (rv != NGX_CONF_OK) {
|
|
705 return rv;
|
|
706 }
|
|
707
|
|
708 rv = ngx_http_merge_locations(cf, &clcfp[i]->locations,
|
|
709 clcfp[i]->loc_conf, module, ctx_index);
|
|
710 if (rv != NGX_CONF_OK) {
|
|
711 return rv;
|
|
712 }
|
|
713 }
|
|
714
|
|
715 return NGX_CONF_OK;
|
|
716 }
|