Mercurial > hg > nginx

comparison src/http/ngx_http.c @ 44:0e81ac0bb3e2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx-0.0.1-2003-01-09-08:36:00 import
author Igor Sysoev <igor@sysoev.ru>
date Thu, 09 Jan 2003 05:36:00 +0000
parents 59e7c7f30d49
children f1ee46c036a4
comparison
equal deleted inserted replaced
43:53cd05892261 44:0e81ac0bb3e2
3 #include <ngx_string.h> 3 #include <ngx_string.h>
4 #include <ngx_socket.h> 4 #include <ngx_socket.h>
5 #include <ngx_listen.h> 5 #include <ngx_listen.h>
6 #include <ngx_http.h> 6 #include <ngx_http.h>
7 #include <ngx_http_config.h> 7 #include <ngx_http_config.h>
8 8 #include <ngx_http_core_module.h>
9 extern ngx_array_t *ngx_listening_sockets; 9
10 10
11 static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, char *dummy);
12
13
14 int ngx_http_max_module;
15
16 ngx_array_t ngx_http_servers; /* array of ngx_http_core_srv_conf_t */
17
18 int ngx_http_post_accept_timeout = 10000;
19 int ngx_http_connection_pool_size = 16384;
20 int ngx_http_request_pool_size = 16384;
21 int ngx_http_client_header_timeout = 20000;
22 int ngx_http_client_header_buffer_size = 1024;
23
24 /* STUB: per location */
25 int ngx_http_lingering_timeout = 5000;
26 int ngx_http_lingering_time = 30;
27 /**/
28
29 int (*ngx_http_top_header_filter) (ngx_http_request_t *r);
30
31
32 static ngx_str_t http_name = ngx_string("http");
33
34
35 static ngx_command_t ngx_http_commands[] = {
36
37 {ngx_string("http"),
38 NGX_CONF_BLOCK|NGX_CONF_NOARGS,
39 ngx_http_block,
40 0,
41 0},
42
43 {ngx_string(""), 0, NULL, 0, 0}
44 };
45
46
47 ngx_module_t ngx_http_module = {
48 0, /* module index */
49 &http_name, /* module context */
50 ngx_http_commands, /* module directives */
51 NGX_CORE_MODULE_TYPE, /* module type */
52 NULL /* init module */
53 };
54
55
56 static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, char *dummy)
57 {
58 int i, s, l, p, a, n, start;
59 int port_found, addr_found, virtual_names;
60 char *rv;
61 struct sockaddr_in *addr_in;
62 ngx_array_t in_ports;
63 ngx_listen_t *ls;
64 ngx_http_module_t *module;
65 ngx_http_conf_ctx_t *ctx, *prev;
66 ngx_http_in_port_t *in_port;
67 ngx_http_in_addr_t *in_addr, *inaddr;
68 ngx_http_core_srv_conf_t **cscf;
69 ngx_http_listen_t *lscf;
70 ngx_http_server_name_t *s_name, *name;;
71
72 ngx_init_array(ngx_http_servers, cf->pool, 10,
73 sizeof(ngx_http_core_srv_conf_t *), NGX_CONF_ERROR);
74
75 ngx_test_null(ctx,
76 ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)),
77 NGX_CONF_ERROR);
78
79 for (i = 0; ngx_modules[i]; i++) {
80 if (ngx_modules[i]->type != NGX_HTTP_MODULE_TYPE) {
81 continue;
82 }
83
84 /* STUB */
85 module = (ngx_http_module_t *) ngx_modules[i]->ctx;
86 module->index = ngx_http_max_module;
87
88 ngx_modules[i]->index = ngx_http_max_module++;
89 }
90
91 /* null loc_conf */
92 ngx_test_null(ctx->loc_conf,
93 ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
94 NGX_CONF_ERROR);
95
96 for (i = 0; ngx_modules[i]; i++) {
97 if (ngx_modules[i]->type != NGX_HTTP_MODULE_TYPE) {
98 continue;
99 }
100
101 module = (ngx_http_module_t *) ngx_modules[i]->ctx;
102
103 if (module->create_loc_conf) {
104 ngx_test_null(ctx->loc_conf[module->index],
105 module->create_loc_conf(cf->pool),
106 NGX_CONF_ERROR);
107 }
108 }
109
110 prev = cf->ctx;
111 cf->ctx = ctx;
112 cf->type = NGX_HTTP_MODULE_TYPE;
113
114 rv = ngx_conf_parse(cf, NULL);
115 cf->ctx = prev;
116
117 if (rv != NGX_CONF_OK)
118 return rv;
119
120 ngx_http_init_filters(cf->pool, ngx_modules);
121
122 #if 1
123 ngx_init_array(in_ports, cf->pool, 10, sizeof(ngx_http_in_port_t),
124 NGX_CONF_ERROR);
125
126 cscf = (ngx_http_core_srv_conf_t **) ngx_http_servers.elts;
127 for (s = 0; s < ngx_http_servers.nelts; s++) {
128
129 lscf = (ngx_http_listen_t *) cscf[s]->listen.elts;
130 for (l = 0; l < cscf[s]->listen.nelts; l++) {
131
132 port_found = 0;
133
134 /* AF_INET only */
135
136 in_port = (ngx_http_in_port_t *) in_ports.elts;
137 for (p = 0; p < in_ports.nelts; p++) {
138
139 if (lscf[l].port == in_port[p].port) {
140
141 port_found = 1;
142 addr_found = 0;
143
144 in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
145 for (a = 0; a < in_port[p].addr.nelts; a++) {
146
147 if (lscf[l].addr == in_addr[a].addr) {
148 s_name = (ngx_http_server_name_t *)
149 cscf[s]->server_names.elts;
150 for (n = 0; n < cscf[s]->server_names.nelts; n++) {
151 ngx_test_null(name,
152 ngx_push_array(&in_addr[a].names),
153 NGX_CONF_ERROR);
154
155 name->name = s_name[n].name;
156 name->core_srv_conf = s_name[n].core_srv_conf;
157 }
158
159 if (lscf[l].flags & NGX_HTTP_DEFAULT_SERVER) {
160 if (in_addr[a].flags
161 & NGX_HTTP_DEFAULT_SERVER) {
162
163 ngx_log_error(NGX_LOG_ERR, cf->log, 0,
164 "duplicate default server in %s:%d",
165 lscf[l].conf_file->file.name.data,
166 lscf[l].line);
167
168 return NGX_CONF_ERROR;
169 }
170
171 in_addr[a].flags |= NGX_HTTP_DEFAULT_SERVER;
172 in_addr[a].core_srv_conf = cscf[s];
173 }
174
175 addr_found = 1;
176
177 break;
178
179 /* "*:XX" is the last resort */
180 } else if (in_addr[p].addr == INADDR_ANY) {
181 ngx_test_null(inaddr,
182 ngx_push_array(&in_port[p].addr),
183 NGX_CONF_ERROR);
184
185 ngx_memcpy(inaddr, &in_addr[a],
186 sizeof(ngx_http_in_addr_t));
187
188 inaddr->addr = lscf[l].addr;
189 inaddr->flags = lscf[l].flags;
190 inaddr->core_srv_conf = cscf[s];
191
192 ngx_init_array(inaddr->names, cf->pool, 10,
193 sizeof(ngx_http_server_name_t),
194 NGX_CONF_ERROR);
195
196 addr_found = 1;
197
198 break;
199 }
200 }
201
202 if (!addr_found) {
203 ngx_test_null(inaddr,
204 ngx_push_array(&in_port[p].addr),
205 NGX_CONF_ERROR);
206
207 inaddr->addr = lscf[l].addr;
208 inaddr->flags = lscf[l].flags;
209 inaddr->core_srv_conf = cscf[s];
210
211 ngx_init_array(inaddr->names, cf->pool, 10,
212 sizeof(ngx_http_server_name_t),
213 NGX_CONF_ERROR);
214 }
215 }
216 }
217
218 if (!port_found) {
219 ngx_test_null(in_port,
220 ngx_push_array(&in_ports),
221 NGX_CONF_ERROR);
222
223 in_port->port = lscf[l].port;
224
225 ngx_init_array(in_port->addr, cf->pool, 10,
226 sizeof(ngx_http_in_addr_t),
227 NGX_CONF_ERROR);
228
229 ngx_test_null(inaddr, ngx_push_array(&in_port[p].addr),
230 NGX_CONF_ERROR);
231
232 inaddr->addr = lscf[l].addr;
233 inaddr->flags = lscf[l].flags;
234 inaddr->core_srv_conf = cscf[s];
235
236 ngx_init_array(inaddr->names, cf->pool, 10,
237 sizeof(ngx_http_server_name_t),
238 NGX_CONF_ERROR);
239 }
240 }
241 }
242
243 /* AF_INET only */
244
245 in_port = (ngx_http_in_port_t *) in_ports.elts;
246 for (p = 0; p < in_ports.nelts; p++) {
247
248 in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
249 for (a = 0; a < in_port[p].addr.nelts; a++) {
250
251 virtual_names = 0;
252
253 name = (ngx_http_server_name_t *) in_addr[a].names.elts;
254 for (n = 0; n < in_addr[a].names.nelts; n++) {
255 if (in_addr[a].core_srv_conf != name[n].core_srv_conf) {
256 virtual_names = 1;
257 break;
258 }
259 }
260
261 /* if all server names point to the same server
262 then we do not need to check them at run time */
263 if (!virtual_names) {
264 in_addr[a].names.nelts = 0;
265 }
266 }
267
268 /* if there is binding to "*:XX" then we need to bind to "*:XX" only
269 and ignore other binding */
270 if (in_addr[a - 1].addr == INADDR_ANY) {
271 start = a - 1;
272
273 } else {
274 start = 0;
275 }
276
277 in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
278 for (a = start; a < in_port[p].addr.nelts; a++) {
279
280 ngx_test_null(ls, ngx_push_array(&ngx_listening_sockets),
281 NGX_CONF_ERROR);
282 ngx_memzero(ls, sizeof(ngx_listen_t));
283
284 ngx_test_null(addr_in,
285 ngx_pcalloc(cf->pool, sizeof(struct sockaddr_in)),
286 NGX_CONF_ERROR);
287
288 addr_in->sin_family = AF_INET;
289 addr_in->sin_addr.s_addr = in_addr[a].addr;
290 addr_in->sin_port = htons(in_port[p].port);
291
292 ngx_test_null(ls->addr_text.data,
293 ngx_palloc(cf->pool, INET_ADDRSTRLEN + 6),
294 NGX_CONF_ERROR);
295
296 ls->addr_text.len =
297 ngx_snprintf(ls->addr_text.data
298 + ngx_inet_ntop(AF_INET,
299 &in_addr[a].addr,
300 ls->addr_text.data,
301 INET_ADDRSTRLEN),
302 6, ":%d", in_port[p].port);
303
304 ls->family = AF_INET;
305 ls->type = SOCK_STREAM;
306 ls->protocol = IPPROTO_IP;
307 #if (NGX_OVERLAPPED)
308 ls->flags = WSA_FLAG_OVERLAPPED;
309 #endif
310 ls->sockaddr = (struct sockaddr *) addr_in;
311 ls->socklen = sizeof(struct sockaddr_in);
312 ls->addr = offsetof(struct sockaddr_in, sin_addr);
313 ls->addr_text_max_len = INET_ADDRSTRLEN;
314 ls->backlog = -1;
315 ls->post_accept_timeout = ngx_http_post_accept_timeout;
316 ls->nonblocking = 1;
317
318 ls->handler = ngx_http_init_connection;
319 ls->log = cf->log;
320 ls->ctx = ctx;
321 ls->servers = &in_port[p].addr;
322
323 if (in_port[p].addr.nelts == 1) {
324 in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
325
326 if (in_addr[a].names.nelts == 0) {
327 ls->ctx = in_addr->core_srv_conf->ctx;
328 ls->servers = NULL;
329 }
330 }
331 }
332 }
333 #endif
334
335 return NGX_CONF_OK;
336 }
337
338
339 #if 0
11 /* STUB */ 340 /* STUB */
12 341
13 static struct sockaddr_in addr; 342 static struct sockaddr_in addr;
14 static char addr_text[22]; 343 static char addr_text[22];
15 344
16 static ngx_http_server_t ngx_http_server;
17 345
18 int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log) 346 int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
19 { 347 {
20 ngx_listen_t *ls; 348 ngx_listen_t *ls;
21 349
38 #endif 366 #endif
39 ngx_http_server.doc_root_len = strlen(ngx_http_server.doc_root) + 1; 367 ngx_http_server.doc_root_len = strlen(ngx_http_server.doc_root) + 1;
40 368
41 369
42 ngx_http_config_modules(pool, ngx_modules); 370 ngx_http_config_modules(pool, ngx_modules);
371
43 #if 0 372 #if 0
44
45 /* STUB */ 373 /* STUB */
46 ngx_http_output_filter_set_stub(pool, ngx_http_modules); 374 ngx_http_output_filter_set_stub(pool, ngx_http_modules);
47 ngx_http_write_filter_set_stub(pool, ngx_http_modules); 375 ngx_http_write_filter_set_stub(pool, ngx_http_modules);
48 ngx_http_index_set_stub(pool, ngx_http_modules); 376 ngx_http_index_set_stub(pool, ngx_http_modules);
49 377
50 ngx_http_init_modules(pool, ngx_http_modules); 378 ngx_http_init_modules(pool, ngx_http_modules);
51 #endif 379 #endif
380
52 ngx_http_init_filters(pool, ngx_modules); 381 ngx_http_init_filters(pool, ngx_modules);
53 382
54 ls = ngx_push_array(ngx_listening_sockets); 383 ls = ngx_push_array(&ngx_listening_sockets);
55 ngx_memzero(ls, sizeof(ngx_listen_t)); 384 ngx_memzero(ls, sizeof(ngx_listen_t));
56 385
57 addr.sin_family = AF_INET; 386 addr.sin_family = AF_INET;
58 addr.sin_addr.s_addr = inet_addr("0.0.0.0"); 387 addr.sin_addr.s_addr = inet_addr("0.0.0.0");
59 addr.sin_port = htons(8000); 388 addr.sin_port = htons(8000);
82 411
83 412
84 return 1; 413 return 1;
85 } 414 }
86 415
87 /* */ 416 /**/
417 #endif