|
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;
|
|
10
|
86 #if (NGX_WIN32)
|
|
0
|
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,
|
|
10
|
346 "the duplicate default server in %V:%d",
|
|
|
347 &lscf[l].file_name, lscf[l].line);
|
|
0
|
348
|
|
|
349 return NGX_CONF_ERROR;
|
|
|
350 }
|
|
|
351
|
|
|
352 in_addr[a].core_srv_conf = cscfp[s];
|
|
|
353 in_addr[a].default_server = 1;
|
|
|
354 }
|
|
|
355
|
|
|
356 addr_found = 1;
|
|
|
357
|
|
|
358 break;
|
|
|
359
|
|
|
360 } else if (in_addr[a].addr == INADDR_ANY) {
|
|
|
361
|
|
4
|
362 /* the INADDR_ANY is always the last address */
|
|
|
363
|
|
|
364 if (!(inaddr = ngx_array_push(&in_port[p].addrs))) {
|
|
|
365 return NGX_CONF_ERROR;
|
|
|
366 }
|
|
|
367
|
|
0
|
368 /*
|
|
4
|
369 * the INADDR_ANY must be the last resort
|
|
|
370 * so we move it to the end of the address list
|
|
|
371 * and put the new address in its place
|
|
0
|
372 */
|
|
|
373
|
|
|
374 ngx_memcpy(inaddr, &in_addr[a],
|
|
|
375 sizeof(ngx_http_in_addr_t));
|
|
|
376
|
|
|
377 in_addr[a].addr = lscf[l].addr;
|
|
4
|
378 in_addr[a].names.elts = NULL;
|
|
0
|
379 in_addr[a].default_server = lscf[l].default_server;
|
|
|
380 in_addr[a].core_srv_conf = cscfp[s];
|
|
|
381
|
|
4
|
382 if (ngx_http_add_names(cf, &in_addr[a], cscfp[s])
|
|
|
383 == NGX_ERROR)
|
|
|
384 {
|
|
|
385 return NGX_CONF_ERROR;
|
|
|
386 }
|
|
0
|
387
|
|
|
388 addr_found = 1;
|
|
|
389
|
|
|
390 break;
|
|
|
391 }
|
|
|
392 }
|
|
|
393
|
|
|
394 if (!addr_found) {
|
|
|
395
|
|
|
396 /*
|
|
|
397 * add the address to the addresses list that
|
|
|
398 * bound to this port
|
|
|
399 */
|
|
|
400
|
|
4
|
401 if (ngx_http_add_address(cf, &in_port[p], &lscf[l],
|
|
|
402 cscfp[s]) == NGX_ERROR)
|
|
|
403 {
|
|
|
404 return NGX_CONF_ERROR;
|
|
|
405 }
|
|
0
|
406 }
|
|
|
407 }
|
|
|
408 }
|
|
|
409
|
|
|
410 if (!port_found) {
|
|
|
411
|
|
|
412 /* add the port to the in_port list */
|
|
|
413
|
|
4
|
414 if (!(in_port = ngx_array_push(&in_ports))) {
|
|
|
415 return NGX_CONF_ERROR;
|
|
|
416 }
|
|
0
|
417
|
|
|
418 in_port->port = lscf[l].port;
|
|
4
|
419 in_port->addrs.elts = NULL;
|
|
0
|
420
|
|
4
|
421 if (!(in_port->port_text.data = ngx_palloc(cf->pool, 7))) {
|
|
|
422 return NGX_CONF_ERROR;
|
|
|
423 }
|
|
0
|
424
|
|
4
|
425 in_port->port_text.len = ngx_sprintf(in_port->port_text.data,
|
|
|
426 ":%d", in_port->port)
|
|
|
427 - in_port->port_text.data;
|
|
0
|
428
|
|
4
|
429 if (ngx_http_add_address(cf, in_port, &lscf[l], cscfp[s])
|
|
|
430 == NGX_ERROR)
|
|
|
431 {
|
|
|
432 return NGX_CONF_ERROR;
|
|
|
433 }
|
|
0
|
434 }
|
|
|
435 }
|
|
|
436 }
|
|
|
437
|
|
4
|
438
|
|
|
439 /* optimize the lists of ports, addresses and server names */
|
|
0
|
440
|
|
|
441 /* AF_INET only */
|
|
|
442
|
|
|
443 in_port = in_ports.elts;
|
|
|
444 for (p = 0; p < in_ports.nelts; p++) {
|
|
|
445
|
|
4
|
446 /*
|
|
|
447 * check whether all name-based servers have the same configuraiton
|
|
|
448 * as the default server, or some servers restrict the host names
|
|
|
449 */
|
|
0
|
450
|
|
|
451 in_addr = in_port[p].addrs.elts;
|
|
|
452 for (a = 0; a < in_port[p].addrs.nelts; a++) {
|
|
|
453
|
|
|
454 virtual_names = 0;
|
|
|
455
|
|
|
456 name = in_addr[a].names.elts;
|
|
|
457 for (n = 0; n < in_addr[a].names.nelts; n++) {
|
|
4
|
458 if (in_addr[a].core_srv_conf != name[n].core_srv_conf
|
|
|
459 || name[n].core_srv_conf->restrict_host_names
|
|
|
460 != NGX_HTTP_RESTRICT_HOST_OFF)
|
|
|
461 {
|
|
0
|
462 virtual_names = 1;
|
|
|
463 break;
|
|
|
464 }
|
|
|
465 }
|
|
|
466
|
|
|
467 /*
|
|
4
|
468 * if all name-based servers have the same configuration
|
|
|
469 * as the default server, and no servers restrict the host names
|
|
|
470 * then we do not need to check them at run-time at all
|
|
0
|
471 */
|
|
|
472
|
|
|
473 if (!virtual_names) {
|
|
|
474 in_addr[a].names.nelts = 0;
|
|
|
475 }
|
|
|
476 }
|
|
|
477
|
|
|
478 /*
|
|
|
479 * if there's the binding to "*:port" then we need to bind()
|
|
|
480 * to "*:port" only and ignore the other bindings
|
|
|
481 */
|
|
|
482
|
|
|
483 if (in_addr[a - 1].addr == INADDR_ANY) {
|
|
|
484 a--;
|
|
|
485
|
|
|
486 } else {
|
|
|
487 a = 0;
|
|
|
488 }
|
|
|
489
|
|
|
490 in_addr = in_port[p].addrs.elts;
|
|
|
491 while (a < in_port[p].addrs.nelts) {
|
|
|
492
|
|
|
493 ls = ngx_listening_inet_stream_socket(cf, in_addr[a].addr,
|
|
|
494 in_port[p].port);
|
|
|
495 if (ls == NULL) {
|
|
|
496 return NGX_CONF_ERROR;
|
|
|
497 }
|
|
|
498
|
|
|
499 ls->backlog = -1;
|
|
|
500 #if 0
|
|
|
501 #if 0
|
|
|
502 ls->nonblocking = 1;
|
|
|
503 #else
|
|
|
504 ls->nonblocking = 0;
|
|
|
505 #endif
|
|
|
506 #endif
|
|
|
507 ls->addr_ntop = 1;
|
|
|
508
|
|
|
509 ls->handler = ngx_http_init_connection;
|
|
|
510
|
|
|
511 cscf = in_addr[a].core_srv_conf;
|
|
|
512 ls->pool_size = cscf->connection_pool_size;
|
|
|
513 ls->post_accept_timeout = cscf->post_accept_timeout;
|
|
|
514
|
|
|
515 clcf = cscf->ctx->loc_conf[ngx_http_core_module.ctx_index];
|
|
|
516 ls->log = clcf->err_log;
|
|
|
517
|
|
10
|
518 #if (NGX_WIN32)
|
|
0
|
519 iocpcf = ngx_event_get_conf(cf->cycle->conf_ctx, ngx_iocp_module);
|
|
|
520 if (iocpcf->acceptex_read) {
|
|
|
521 ls->post_accept_buffer_size = cscf->client_header_buffer_size;
|
|
|
522 }
|
|
|
523 #endif
|
|
|
524
|
|
|
525 ls->ctx = ctx;
|
|
|
526
|
|
|
527 if (in_port[p].addrs.nelts > 1) {
|
|
|
528
|
|
|
529 in_addr = in_port[p].addrs.elts;
|
|
|
530 if (in_addr[in_port[p].addrs.nelts - 1].addr != INADDR_ANY) {
|
|
|
531
|
|
|
532 /*
|
|
|
533 * if this port has not the "*:port" binding then create
|
|
|
534 * the separate ngx_http_in_port_t for the all bindings
|
|
|
535 */
|
|
|
536
|
|
|
537 ngx_test_null(inport,
|
|
|
538 ngx_palloc(cf->pool,
|
|
|
539 sizeof(ngx_http_in_port_t)),
|
|
|
540 NGX_CONF_ERROR);
|
|
|
541
|
|
|
542 inport->port = in_port[p].port;
|
|
|
543 inport->port_text = in_port[p].port_text;
|
|
|
544
|
|
|
545 /* init list of the addresses ... */
|
|
|
546
|
|
|
547 ngx_init_array(inport->addrs, cf->pool, 1,
|
|
|
548 sizeof(ngx_http_in_addr_t),
|
|
|
549 NGX_CONF_ERROR);
|
|
|
550
|
|
|
551 /* ... and set up it with the first address */
|
|
|
552
|
|
|
553 inport->addrs.nelts = 1;
|
|
|
554 inport->addrs.elts = in_port[p].addrs.elts;
|
|
|
555
|
|
|
556 ls->servers = inport;
|
|
|
557
|
|
|
558 /* prepare for the next cycle */
|
|
|
559
|
|
|
560 in_port[p].addrs.elts = (char *) in_port[p].addrs.elts
|
|
|
561 + in_port[p].addrs.size;
|
|
|
562 in_port[p].addrs.nelts--;
|
|
|
563
|
|
|
564 in_addr = (ngx_http_in_addr_t *) in_port[p].addrs.elts;
|
|
|
565 a = 0;
|
|
|
566
|
|
|
567 continue;
|
|
|
568 }
|
|
|
569 }
|
|
|
570
|
|
|
571 ls->servers = &in_port[p];
|
|
|
572 a++;
|
|
|
573 }
|
|
|
574 }
|
|
|
575
|
|
|
576 #if (NGX_DEBUG)
|
|
4
|
577 {
|
|
|
578 u_char address[20];
|
|
|
579 ngx_uint_t p, a, n;
|
|
|
580
|
|
0
|
581 in_port = in_ports.elts;
|
|
|
582 for (p = 0; p < in_ports.nelts; p++) {
|
|
|
583 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
10
|
584 "port: %d %p", in_port[p].port, &in_port[p]);
|
|
0
|
585 in_addr = in_port[p].addrs.elts;
|
|
|
586 for (a = 0; a < in_port[p].addrs.nelts; a++) {
|
|
4
|
587 ngx_inet_ntop(AF_INET, &in_addr[a].addr, address, 20);
|
|
|
588 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
10
|
589 "%s:%d %p",
|
|
4
|
590 address, in_port[p].port, in_addr[a].core_srv_conf);
|
|
0
|
591 s_name = in_addr[a].names.elts;
|
|
|
592 for (n = 0; n < in_addr[a].names.nelts; n++) {
|
|
4
|
593 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
10
|
594 "%s:%d %V %p",
|
|
|
595 address, in_port[p].port, &s_name[n].name,
|
|
0
|
596 s_name[n].core_srv_conf);
|
|
|
597 }
|
|
|
598 }
|
|
|
599 }
|
|
4
|
600 }
|
|
0
|
601 #endif
|
|
|
602
|
|
|
603 return NGX_CONF_OK;
|
|
|
604 }
|
|
|
605
|
|
|
606
|
|
4
|
607 /*
|
|
|
608 * add the server address, the server names and the server core module
|
|
|
609 * configurations to the port (in_port)
|
|
|
610 */
|
|
|
611
|
|
|
612 static ngx_int_t ngx_http_add_address(ngx_conf_t *cf,
|
|
|
613 ngx_http_in_port_t *in_port,
|
|
|
614 ngx_http_listen_t *lscf,
|
|
|
615 ngx_http_core_srv_conf_t *cscf)
|
|
|
616 {
|
|
|
617 ngx_http_in_addr_t *in_addr;
|
|
|
618
|
|
|
619 if (in_port->addrs.elts == NULL) {
|
|
|
620 if (ngx_array_init(&in_port->addrs, cf->pool, 10,
|
|
|
621 sizeof(ngx_http_in_addr_t)) == NGX_ERROR)
|
|
|
622 {
|
|
|
623 return NGX_ERROR;
|
|
|
624 }
|
|
|
625 }
|
|
|
626
|
|
|
627 if (!(in_addr = ngx_array_push(&in_port->addrs))) {
|
|
|
628 return NGX_ERROR;
|
|
|
629 }
|
|
|
630
|
|
|
631 in_addr->addr = lscf->addr;
|
|
|
632 in_addr->names.elts = NULL;
|
|
|
633 in_addr->default_server = lscf->default_server;
|
|
|
634 in_addr->core_srv_conf = cscf;
|
|
|
635
|
|
|
636 #if (NGX_DEBUG)
|
|
|
637 {
|
|
|
638 u_char text[20];
|
|
|
639 ngx_inet_ntop(AF_INET, &in_addr->addr, text, 20);
|
|
|
640 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0, "address: %s:%d",
|
|
|
641 text, in_port->port);
|
|
|
642 }
|
|
|
643 #endif
|
|
|
644
|
|
|
645 return ngx_http_add_names(cf, in_addr, cscf);
|
|
|
646 }
|
|
|
647
|
|
|
648
|
|
|
649 /*
|
|
|
650 * add the server names and the server core module
|
|
|
651 * configurations to the address:port (in_addr)
|
|
|
652 */
|
|
|
653
|
|
|
654 static ngx_int_t ngx_http_add_names(ngx_conf_t *cf,
|
|
|
655 ngx_http_in_addr_t *in_addr,
|
|
|
656 ngx_http_core_srv_conf_t *cscf)
|
|
|
657 {
|
|
|
658 ngx_uint_t i;
|
|
|
659 ngx_http_server_name_t *server_names, *name;
|
|
|
660
|
|
|
661 if (in_addr->names.elts == NULL) {
|
|
|
662 if (ngx_array_init(&in_addr->names, cf->pool, 10,
|
|
|
663 sizeof(ngx_http_server_name_t)) == NGX_ERROR)
|
|
|
664 {
|
|
|
665 return NGX_ERROR;
|
|
|
666 }
|
|
|
667 }
|
|
|
668
|
|
|
669 server_names = cscf->server_names.elts;
|
|
|
670 for (i = 0; i < cscf->server_names.nelts; i++) {
|
|
|
671
|
|
|
672 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, cf->log, 0,
|
|
10
|
673 "name: %V", &server_names[i].name);
|
|
4
|
674
|
|
|
675 /* TODO: duplicate names can be checked here */
|
|
|
676
|
|
|
677 if (!(name = ngx_array_push(&in_addr->names))) {
|
|
|
678 return NGX_ERROR;
|
|
|
679 }
|
|
|
680
|
|
|
681 *name = server_names[i];
|
|
|
682 }
|
|
|
683
|
|
|
684 return NGX_OK;
|
|
|
685 }
|
|
|
686
|
|
|
687
|
|
0
|
688 static char *ngx_http_merge_locations(ngx_conf_t *cf,
|
|
|
689 ngx_array_t *locations,
|
|
|
690 void **loc_conf,
|
|
|
691 ngx_http_module_t *module,
|
|
|
692 ngx_uint_t ctx_index)
|
|
|
693 {
|
|
|
694 char *rv;
|
|
|
695 ngx_uint_t i;
|
|
|
696 ngx_http_core_loc_conf_t **clcfp;
|
|
|
697
|
|
|
698 clcfp = /* (ngx_http_core_loc_conf_t **) */ locations->elts;
|
|
|
699
|
|
|
700 for (i = 0; i < locations->nelts; i++) {
|
|
|
701 rv = module->merge_loc_conf(cf, loc_conf[ctx_index],
|
|
|
702 clcfp[i]->loc_conf[ctx_index]);
|
|
|
703 if (rv != NGX_CONF_OK) {
|
|
|
704 return rv;
|
|
|
705 }
|
|
|
706
|
|
|
707 rv = ngx_http_merge_locations(cf, &clcfp[i]->locations,
|
|
|
708 clcfp[i]->loc_conf, module, ctx_index);
|
|
|
709 if (rv != NGX_CONF_OK) {
|
|
|
710 return rv;
|
|
|
711 }
|
|
|
712 }
|
|
|
713
|
|
|
714 return NGX_CONF_OK;
|
|
|
715 }
|
