Mercurial > hg > nginx-vendor-1-0
comparison src/http/modules/ngx_http_fastcgi_module.c @ 50:72eb30262aac NGINX_0_1_25
nginx 0.1.25
*) Bugfix: nginx did run on Linux parisc.
*) Feature: nginx now does not start under FreeBSD if the sysctl
kern.ipc.somaxconn value is too big.
*) Bugfix: if a request was internally redirected by the
ngx_http_index_module module to the ngx_http_proxy_module or
ngx_http_fastcgi_module modules, then the index file was not closed
after request completion.
*) Feature: the "proxy_pass" can be used in location with regular
expression.
*) Feature: the ngx_http_rewrite_filter_module module supports the
condition like "if ($HTTP_USER_AGENT ~ MSIE)".
*) Bugfix: nginx started too slow if the large number of addresses and
text values were used in the "geo" directive.
*) Change: a variable name must be declared as "$name" in the "geo"
directive. The previous variant without "$" is still supported, but
will be removed soon.
*) Feature: the "%{VARIABLE}v" logging parameter.
*) Feature: the "set $name value" directive.
*) Bugfix: gcc 4.0 compatibility.
*) Feature: the --with-openssl-opt=OPTIONS autoconfiguration directive.
author | Igor Sysoev <http://sysoev.ru> |
---|---|
date | Sat, 19 Mar 2005 00:00:00 +0300 |
parents | |
children | 0d75d65c642f |
comparison
equal
deleted
inserted
replaced
49:93dabbc9efb9 | 50:72eb30262aac |
---|---|
1 | |
2 /* | |
3 * Copyright (C) Igor Sysoev | |
4 */ | |
5 | |
6 | |
7 #include <ngx_config.h> | |
8 #include <ngx_core.h> | |
9 #include <ngx_http.h> | |
10 #include <nginx.h> | |
11 | |
12 | |
13 typedef struct { | |
14 ngx_http_upstream_conf_t upstream; | |
15 | |
16 ngx_peers_t *peers; | |
17 | |
18 ngx_uint_t params; | |
19 | |
20 ngx_str_t root; | |
21 ngx_str_t index; | |
22 | |
23 ngx_array_t *vars; | |
24 | |
25 ngx_str_t *location; | |
26 } ngx_http_fastcgi_loc_conf_t; | |
27 | |
28 | |
29 typedef struct { | |
30 ngx_list_t headers; | |
31 | |
32 ngx_table_elt_t *status; | |
33 | |
34 ngx_table_elt_t *content_type; | |
35 ngx_table_elt_t *content_length; | |
36 ngx_table_elt_t *x_powered_by; | |
37 | |
38 #if (NGX_HTTP_GZIP) | |
39 ngx_table_elt_t *content_encoding; | |
40 #endif | |
41 } ngx_http_fastcgi_headers_in_t; | |
42 | |
43 | |
44 typedef struct { | |
45 ngx_http_fastcgi_headers_in_t headers_in; | |
46 } ngx_http_fastcgi_upstream_t; | |
47 | |
48 | |
49 typedef enum { | |
50 ngx_http_fastcgi_st_version = 0, | |
51 ngx_http_fastcgi_st_type, | |
52 ngx_http_fastcgi_st_request_id_hi, | |
53 ngx_http_fastcgi_st_request_id_lo, | |
54 ngx_http_fastcgi_st_content_length_hi, | |
55 ngx_http_fastcgi_st_content_length_lo, | |
56 ngx_http_fastcgi_st_padding_length, | |
57 ngx_http_fastcgi_st_reserved, | |
58 ngx_http_fastcgi_st_data, | |
59 ngx_http_fastcgi_st_padding, | |
60 } ngx_http_fastcgi_state_e; | |
61 | |
62 | |
63 typedef struct { | |
64 ngx_http_fastcgi_state_e state; | |
65 u_char *pos; | |
66 u_char *last; | |
67 ngx_uint_t type; | |
68 size_t length; | |
69 size_t padding; | |
70 | |
71 ngx_uint_t header; | |
72 | |
73 ngx_http_fastcgi_upstream_t *upstream; | |
74 } ngx_http_fastcgi_ctx_t; | |
75 | |
76 | |
77 #define NGX_HTTP_FASTCGI_REMOTE_ADDR 0x00000002 | |
78 #define NGX_HTTP_FASTCGI_REMOTE_USER 0x00000004 | |
79 #define NGX_HTTP_FASTCGI_SERVER_NAME 0x00000008 | |
80 #define NGX_HTTP_FASTCGI_SERVER_ADDR 0x00000010 | |
81 #define NGX_HTTP_FASTCGI_SERVER_PORT 0x00000020 | |
82 #define NGX_HTTP_FASTCGI_SCRIPT_NAME 0x00000040 | |
83 #define NGX_HTTP_FASTCGI_AUTH_TYPE 0x00000080 | |
84 #define NGX_HTTP_FASTCGI_SERVER_PROTOCOL 0x00000100 | |
85 #define NGX_HTTP_FASTCGI_SERVER_SOFTWARE 0x00000200 | |
86 #define NGX_HTTP_FASTCGI_GATEWAY_INTERFACE 0x00000400 | |
87 #define NGX_HTTP_FASTCGI_REQUEST_URI 0x00000800 | |
88 #define NGX_HTTP_FASTCGI_REDIRECT_STATUS 0x00001000 | |
89 #define NGX_HTTP_FASTCGI_DOCUMENT_ROOT 0x00002000 | |
90 #define NGX_HTTP_FASTCGI_SCRIPT_FILENAME 0x00004000 | |
91 #define NGX_HTTP_FASTCGI_REMOTE_PORT 0x00008000 | |
92 | |
93 | |
94 #define NGX_HTTP_FASTCGI_RESPONDER 1 | |
95 | |
96 #define NGX_HTTP_FASTCGI_BEGIN_REQUEST 1 | |
97 #define NGX_HTTP_FASTCGI_ABORT_REQUEST 2 | |
98 #define NGX_HTTP_FASTCGI_END_REQUEST 3 | |
99 #define NGX_HTTP_FASTCGI_PARAMS 4 | |
100 #define NGX_HTTP_FASTCGI_STDIN 5 | |
101 #define NGX_HTTP_FASTCGI_STDOUT 6 | |
102 #define NGX_HTTP_FASTCGI_STDERR 7 | |
103 #define NGX_HTTP_FASTCGI_DATA 8 | |
104 | |
105 | |
106 typedef struct { | |
107 u_char version; | |
108 u_char type; | |
109 u_char request_id_hi; | |
110 u_char request_id_lo; | |
111 u_char content_length_hi; | |
112 u_char content_length_lo; | |
113 u_char padding_length; | |
114 u_char reserved; | |
115 } ngx_http_fastcgi_header_t; | |
116 | |
117 | |
118 typedef struct { | |
119 u_char role_hi; | |
120 u_char role_lo; | |
121 u_char flags; | |
122 u_char reserved[5]; | |
123 } ngx_http_fastcgi_begin_request_t; | |
124 | |
125 | |
126 static ngx_int_t ngx_http_fastcgi_create_request(ngx_http_request_t *r); | |
127 static ngx_int_t ngx_http_fastcgi_reinit_request(ngx_http_request_t *r); | |
128 static ngx_int_t ngx_http_fastcgi_process_header(ngx_http_request_t *r); | |
129 static ngx_int_t ngx_http_fastcgi_send_header(ngx_http_request_t *r); | |
130 static ngx_int_t ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p, | |
131 ngx_buf_t *buf); | |
132 static ngx_int_t ngx_http_fastcgi_process_record(ngx_http_request_t *r, | |
133 ngx_http_fastcgi_ctx_t *f); | |
134 static void ngx_http_fastcgi_abort_request(ngx_http_request_t *r); | |
135 static void ngx_http_fastcgi_finalize_request(ngx_http_request_t *r, | |
136 ngx_int_t rc); | |
137 | |
138 static char *ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, | |
139 void *conf); | |
140 static char *ngx_http_fastcgi_set_var(ngx_conf_t *cf, ngx_command_t *cmd, | |
141 void *conf); | |
142 static char *ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post, | |
143 void *data); | |
144 static void *ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf); | |
145 static char *ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf, | |
146 void *parent, void *child); | |
147 | |
148 | |
149 static ngx_str_t ngx_http_fastcgi_methods[] = { | |
150 ngx_string("GET"), | |
151 ngx_string("HEAD"), | |
152 ngx_string("POST") | |
153 }; | |
154 | |
155 | |
156 static ngx_str_t ngx_http_fastcgi_uri = ngx_string("/"); | |
157 | |
158 | |
159 static ngx_http_header_t ngx_http_fastcgi_headers_in[] = { | |
160 { ngx_string("Status"), offsetof(ngx_http_fastcgi_headers_in_t, status) }, | |
161 | |
162 { ngx_string("Content-Type"), | |
163 offsetof(ngx_http_fastcgi_headers_in_t, content_type) }, | |
164 | |
165 { ngx_string("Content-Length"), | |
166 offsetof(ngx_http_fastcgi_headers_in_t, content_length) }, | |
167 | |
168 { ngx_string("X-Powered-By"), | |
169 offsetof(ngx_http_fastcgi_headers_in_t, x_powered_by) }, | |
170 | |
171 #if (NGX_HTTP_GZIP) | |
172 { ngx_string("Content-Encoding"), | |
173 offsetof(ngx_http_fastcgi_headers_in_t, content_encoding) }, | |
174 #endif | |
175 | |
176 { ngx_null_string, 0 } | |
177 }; | |
178 | |
179 | |
180 static ngx_conf_post_t ngx_http_fastcgi_lowat_post = | |
181 { ngx_http_fastcgi_lowat_check }; | |
182 | |
183 static ngx_conf_bitmask_t ngx_http_fastcgi_next_upstream_masks[] = { | |
184 { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR }, | |
185 { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT }, | |
186 { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER }, | |
187 { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 }, | |
188 { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 }, | |
189 { ngx_null_string, 0 } | |
190 }; | |
191 | |
192 | |
193 static ngx_conf_bitmask_t ngx_http_fastcgi_params_masks[] = { | |
194 { ngx_string("remote_addr"), NGX_HTTP_FASTCGI_REMOTE_ADDR }, | |
195 { ngx_string("server_port"), NGX_HTTP_FASTCGI_SERVER_PORT }, | |
196 { ngx_string("server_addr"), NGX_HTTP_FASTCGI_SERVER_ADDR }, | |
197 { ngx_string("server_name"), NGX_HTTP_FASTCGI_SERVER_NAME }, | |
198 { ngx_string("script_name"), NGX_HTTP_FASTCGI_SCRIPT_NAME }, | |
199 | |
200 { ngx_string("server_protocol"), NGX_HTTP_FASTCGI_SERVER_PROTOCOL }, | |
201 { ngx_string("server_software"), NGX_HTTP_FASTCGI_SERVER_SOFTWARE }, | |
202 { ngx_string("gateway_interface"), NGX_HTTP_FASTCGI_GATEWAY_INTERFACE }, | |
203 | |
204 { ngx_string("redirect_status"), NGX_HTTP_FASTCGI_REDIRECT_STATUS }, | |
205 { ngx_string("request_uri"), NGX_HTTP_FASTCGI_REQUEST_URI }, | |
206 | |
207 { ngx_string("document_root"), NGX_HTTP_FASTCGI_DOCUMENT_ROOT }, | |
208 { ngx_string("script_filename"), NGX_HTTP_FASTCGI_SCRIPT_FILENAME }, | |
209 { ngx_string("remote_port"), NGX_HTTP_FASTCGI_REMOTE_PORT }, | |
210 | |
211 { ngx_null_string, 0 } | |
212 }; | |
213 | |
214 | |
215 static ngx_command_t ngx_http_fastcgi_commands[] = { | |
216 | |
217 { ngx_string("fastcgi_pass"), | |
218 NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
219 ngx_http_fastcgi_pass, | |
220 NGX_HTTP_LOC_CONF_OFFSET, | |
221 0, | |
222 NULL }, | |
223 | |
224 { ngx_string("fastcgi_root"), | |
225 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
226 ngx_conf_set_str_slot, | |
227 NGX_HTTP_LOC_CONF_OFFSET, | |
228 offsetof(ngx_http_fastcgi_loc_conf_t, root), | |
229 NULL }, | |
230 | |
231 { ngx_string("fastcgi_index"), | |
232 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
233 ngx_conf_set_str_slot, | |
234 NGX_HTTP_LOC_CONF_OFFSET, | |
235 offsetof(ngx_http_fastcgi_loc_conf_t, index), | |
236 NULL }, | |
237 | |
238 { ngx_string("fastcgi_connect_timeout"), | |
239 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
240 ngx_conf_set_msec_slot, | |
241 NGX_HTTP_LOC_CONF_OFFSET, | |
242 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.connect_timeout), | |
243 NULL }, | |
244 | |
245 { ngx_string("fastcgi_send_timeout"), | |
246 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
247 ngx_conf_set_msec_slot, | |
248 NGX_HTTP_LOC_CONF_OFFSET, | |
249 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.send_timeout), | |
250 NULL }, | |
251 | |
252 { ngx_string("fastcgi_send_lowat"), | |
253 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
254 ngx_conf_set_size_slot, | |
255 NGX_HTTP_LOC_CONF_OFFSET, | |
256 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.send_lowat), | |
257 &ngx_http_fastcgi_lowat_post }, | |
258 | |
259 { ngx_string("fastcgi_header_buffer_size"), | |
260 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
261 ngx_conf_set_size_slot, | |
262 NGX_HTTP_LOC_CONF_OFFSET, | |
263 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.header_buffer_size), | |
264 NULL }, | |
265 | |
266 { ngx_string("fastcgi_redirect_errors"), | |
267 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG, | |
268 ngx_conf_set_flag_slot, | |
269 NGX_HTTP_LOC_CONF_OFFSET, | |
270 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.redirect_errors), | |
271 NULL }, | |
272 | |
273 { ngx_string("fastcgi_x_powered_by"), | |
274 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG, | |
275 ngx_conf_set_flag_slot, | |
276 NGX_HTTP_LOC_CONF_OFFSET, | |
277 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.x_powered_by), | |
278 NULL }, | |
279 | |
280 { ngx_string("fastcgi_read_timeout"), | |
281 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
282 ngx_conf_set_msec_slot, | |
283 NGX_HTTP_LOC_CONF_OFFSET, | |
284 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.read_timeout), | |
285 NULL }, | |
286 | |
287 { ngx_string("fastcgi_buffers"), | |
288 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2, | |
289 ngx_conf_set_bufs_slot, | |
290 NGX_HTTP_LOC_CONF_OFFSET, | |
291 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.bufs), | |
292 NULL }, | |
293 | |
294 { ngx_string("fastcgi_busy_buffers_size"), | |
295 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
296 ngx_conf_set_size_slot, | |
297 NGX_HTTP_LOC_CONF_OFFSET, | |
298 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.busy_buffers_size), | |
299 NULL }, | |
300 | |
301 { ngx_string("fastcgi_temp_path"), | |
302 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234, | |
303 ngx_conf_set_path_slot, | |
304 NGX_HTTP_LOC_CONF_OFFSET, | |
305 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.temp_path), | |
306 (void *) ngx_garbage_collector_temp_handler }, | |
307 | |
308 { ngx_string("fastcgi_max_temp_file_size"), | |
309 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
310 ngx_conf_set_size_slot, | |
311 NGX_HTTP_LOC_CONF_OFFSET, | |
312 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.max_temp_file_size), | |
313 NULL }, | |
314 | |
315 { ngx_string("fastcgi_temp_file_write_size"), | |
316 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
317 ngx_conf_set_size_slot, | |
318 NGX_HTTP_LOC_CONF_OFFSET, | |
319 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.temp_file_write_size), | |
320 NULL }, | |
321 | |
322 { ngx_string("fastcgi_next_upstream"), | |
323 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_ANY, | |
324 ngx_conf_set_bitmask_slot, | |
325 NGX_HTTP_LOC_CONF_OFFSET, | |
326 offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream), | |
327 &ngx_http_fastcgi_next_upstream_masks }, | |
328 | |
329 { ngx_string("fastcgi_set_var"), | |
330 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1, | |
331 ngx_http_fastcgi_set_var, | |
332 NGX_HTTP_LOC_CONF_OFFSET, | |
333 0, | |
334 NULL }, | |
335 | |
336 { ngx_string("fastcgi_params"), | |
337 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_ANY, | |
338 ngx_conf_set_bitmask_slot, | |
339 NGX_HTTP_LOC_CONF_OFFSET, | |
340 offsetof(ngx_http_fastcgi_loc_conf_t, params), | |
341 &ngx_http_fastcgi_params_masks }, | |
342 | |
343 ngx_null_command | |
344 }; | |
345 | |
346 | |
347 ngx_http_module_t ngx_http_fastcgi_module_ctx = { | |
348 NULL, /* pre conf */ | |
349 | |
350 NULL, /* create main configuration */ | |
351 NULL, /* init main configuration */ | |
352 | |
353 NULL, /* create server configuration */ | |
354 NULL, /* merge server configuration */ | |
355 | |
356 ngx_http_fastcgi_create_loc_conf, /* create location configuration */ | |
357 ngx_http_fastcgi_merge_loc_conf /* merge location configuration */ | |
358 }; | |
359 | |
360 | |
361 ngx_module_t ngx_http_fastcgi_module = { | |
362 NGX_MODULE, | |
363 &ngx_http_fastcgi_module_ctx, /* module context */ | |
364 ngx_http_fastcgi_commands, /* module directives */ | |
365 NGX_HTTP_MODULE, /* module type */ | |
366 NULL, /* init module */ | |
367 NULL /* init process */ | |
368 }; | |
369 | |
370 | |
371 static ngx_int_t | |
372 ngx_http_fastcgi_handler(ngx_http_request_t *r) | |
373 { | |
374 ngx_int_t rc; | |
375 ngx_http_upstream_t *u; | |
376 ngx_http_fastcgi_loc_conf_t *flcf; | |
377 | |
378 flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module); | |
379 | |
380 u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t)); | |
381 if (u == NULL) { | |
382 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
383 } | |
384 | |
385 u->peer.log = r->connection->log; | |
386 u->peer.log_error = NGX_ERROR_ERR; | |
387 u->peer.peers = flcf->peers; | |
388 u->peer.tries = flcf->peers->number; | |
389 #if (NGX_THREADS) | |
390 u->peer.lock = &r->connection->lock; | |
391 #endif | |
392 | |
393 u->output.tag = (ngx_buf_tag_t) &ngx_http_fastcgi_module; | |
394 | |
395 u->conf = &flcf->upstream; | |
396 | |
397 u->location = flcf->location; | |
398 | |
399 u->create_request = ngx_http_fastcgi_create_request; | |
400 u->reinit_request = ngx_http_fastcgi_reinit_request; | |
401 u->process_header = ngx_http_fastcgi_process_header; | |
402 u->send_header = ngx_http_fastcgi_send_header; | |
403 u->abort_request = ngx_http_fastcgi_abort_request; | |
404 u->finalize_request = ngx_http_fastcgi_finalize_request; | |
405 | |
406 u->pipe.input_filter = ngx_http_fastcgi_input_filter; | |
407 u->pipe.input_ctx = r; | |
408 | |
409 u->log_ctx = r->connection->log->data; | |
410 u->log_handler = ngx_http_upstream_log_error; | |
411 | |
412 u->schema.len = sizeof("fastcgi://") - 1; | |
413 u->schema.data = (u_char *) "fastcgi://"; | |
414 u->uri.len = sizeof("/") - 1; | |
415 u->uri.data = (u_char *) "/"; | |
416 | |
417 r->upstream = u; | |
418 | |
419 rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init); | |
420 | |
421 if (rc >= NGX_HTTP_SPECIAL_RESPONSE) { | |
422 return rc; | |
423 } | |
424 | |
425 return NGX_DONE; | |
426 } | |
427 | |
428 | |
429 static ngx_int_t | |
430 ngx_http_fastcgi_create_request(ngx_http_request_t *r) | |
431 { | |
432 u_char ch, *pos, addr_text[INET_ADDRSTRLEN], | |
433 port_text[sizeof("65535") - 1]; | |
434 size_t size, len, index, padding, | |
435 addr_len, port_len; | |
436 off_t file_pos; | |
437 ngx_buf_t *b; | |
438 socklen_t slen; | |
439 ngx_chain_t *cl, *body; | |
440 ngx_uint_t i, n, next, *vindex, port; | |
441 ngx_list_part_t *part; | |
442 ngx_table_elt_t *header; | |
443 struct sockaddr_in sin, *sinp; | |
444 ngx_http_variable_t *var; | |
445 ngx_http_variable_value_t *value; | |
446 ngx_http_core_loc_conf_t *clcf; | |
447 ngx_http_core_main_conf_t *cmcf; | |
448 ngx_http_fastcgi_header_t *h; | |
449 ngx_http_fastcgi_loc_conf_t *flcf; | |
450 ngx_http_fastcgi_begin_request_t *br; | |
451 | |
452 | |
453 flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module); | |
454 | |
455 if ((flcf->params & NGX_HTTP_FASTCGI_SERVER_ADDR) && r->in_addr == 0) { | |
456 | |
457 slen = sizeof(struct sockaddr_in); | |
458 if (getsockname(r->connection->fd, | |
459 (struct sockaddr *) &sin, &slen) == -1) | |
460 { | |
461 ngx_log_error(NGX_LOG_CRIT, r->connection->log, | |
462 ngx_socket_errno, "getsockname() failed"); | |
463 return NGX_ERROR; | |
464 } | |
465 | |
466 r->in_addr = sin.sin_addr.s_addr; | |
467 } | |
468 | |
469 addr_len = ngx_inet_ntop(r->connection->listening->family, &r->in_addr, | |
470 addr_text, INET_ADDRSTRLEN); | |
471 if (addr_len == 0) { | |
472 return NGX_ERROR; | |
473 } | |
474 | |
475 #if (NGX_SUPPRESS_WARN) | |
476 clcf = NULL; | |
477 var = NULL; | |
478 vindex = NULL; | |
479 #endif | |
480 | |
481 | |
482 if (r->upstream->method) { | |
483 len = 1 + 1 + sizeof("REQUEST_METHOD") - 1 | |
484 + ngx_http_fastcgi_methods[r->upstream->method - 1].len; | |
485 | |
486 } else { | |
487 len = 1 + ((r->method_name.len - 1 > 127) ? 4 : 1) | |
488 + sizeof("REQUEST_METHOD") - 1 | |
489 + r->method_name.len - 1; | |
490 } | |
491 | |
492 | |
493 index = (r->uri.data[r->uri.len - 1] == '/') ? flcf->index.len : 0; | |
494 | |
495 len += 1 + ((flcf->root.len + r->uri.len + index > 127) ? 4 : 1) | |
496 + sizeof("PATH_TRANSLATED") - 1 + flcf->root.len + r->uri.len + index; | |
497 | |
498 if (r->args.len) { | |
499 len += 1 + ((r->args.len > 127) ? 4 : 1) + sizeof("QUERY_STRING") - 1 | |
500 + r->args.len; | |
501 } | |
502 | |
503 if (r->headers_in.content_length_n > 0) { | |
504 len += 1 + ((r->headers_in.content_length->value.len > 127) ? 4 : 1) | |
505 + sizeof("CONTENT_LENGTH") - 1 | |
506 + r->headers_in.content_length->value.len; | |
507 } | |
508 | |
509 | |
510 if (r->headers_in.content_type) { | |
511 len += 1 + ((r->headers_in.content_type->value.len > 127) ? 4 : 1) | |
512 + sizeof("CONTENT_TYPE") - 1 | |
513 + r->headers_in.content_type->value.len; | |
514 } | |
515 | |
516 | |
517 if (flcf->params & NGX_HTTP_FASTCGI_REDIRECT_STATUS) { | |
518 len += 1 + 1 + sizeof("REDIRECT_STATUS200") - 1; | |
519 } | |
520 | |
521 if (flcf->params & NGX_HTTP_FASTCGI_REQUEST_URI) { | |
522 len += 1 + ((r->unparsed_uri.len > 127) ? 4 : 1) | |
523 + sizeof("REQUEST_URI") - 1 + r->unparsed_uri.len; | |
524 } | |
525 | |
526 if (flcf->params & NGX_HTTP_FASTCGI_DOCUMENT_ROOT) { | |
527 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module); | |
528 len += 1 + ((clcf->root.len > 127) ? 4 : 1) | |
529 + sizeof("DOCUMENT_ROOT") - 1 + clcf->root.len; | |
530 } | |
531 | |
532 if (flcf->params & NGX_HTTP_FASTCGI_SCRIPT_FILENAME) { | |
533 len += 1 + ((flcf->root.len + r->uri.len + index > 127) ? 4 : 1) | |
534 + sizeof("SCRIPT_FILENAME") - 1 | |
535 + flcf->root.len + r->uri.len + index; | |
536 } | |
537 | |
538 if (flcf->params & NGX_HTTP_FASTCGI_SCRIPT_NAME) { | |
539 len += 1 + ((r->uri.len + index > 127) ? 4 : 1) | |
540 + sizeof("SCRIPT_NAME") - 1 + r->uri.len + index ; | |
541 } | |
542 | |
543 if (flcf->params & NGX_HTTP_FASTCGI_REMOTE_ADDR) { | |
544 len += 1 + 1 + sizeof("REMOTE_ADDR") - 1 + r->connection->addr_text.len; | |
545 } | |
546 | |
547 port_len = 0; | |
548 | |
549 if (flcf->params & NGX_HTTP_FASTCGI_REMOTE_PORT) { | |
550 | |
551 /* AF_INET only */ | |
552 | |
553 if (r->connection->sockaddr->sa_family == AF_INET) { | |
554 sinp = (struct sockaddr_in *) r->connection->sockaddr; | |
555 | |
556 port = ntohs(sinp->sin_port); | |
557 | |
558 if (port > 0 && port < 65536) { | |
559 port_len = ngx_sprintf(port_text, "%ui", port) - port_text; | |
560 } | |
561 | |
562 len += 1 + 1 + sizeof("REMOTE_PORT") - 1 + port_len; | |
563 } | |
564 } | |
565 | |
566 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_NAME) { | |
567 len += 1 + 1 + sizeof("SERVER_NAME") - 1 + r->server_name.len; | |
568 } | |
569 | |
570 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_PORT) { | |
571 len += 1 + 1 + sizeof("SERVER_PORT") - 1 + r->port_text->len - 1; | |
572 } | |
573 | |
574 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_ADDR) { | |
575 len += 1 + 1 + sizeof("SERVER_ADDR") - 1 + addr_len; | |
576 } | |
577 | |
578 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_PROTOCOL | |
579 && r->http_protocol.len) | |
580 { | |
581 len += 1 + ((r->http_protocol.len > 127) ? 4 : 1) | |
582 + sizeof("SERVER_PROTOCOL") - 1 + r->http_protocol.len; | |
583 } | |
584 | |
585 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_SOFTWARE) { | |
586 len += 1 + 1 + sizeof("SERVER_SOFTWARE") - 1 + sizeof(NGINX_VER) - 1; | |
587 } | |
588 | |
589 if (flcf->params & NGX_HTTP_FASTCGI_GATEWAY_INTERFACE) { | |
590 len += 1 + 1 + sizeof("GATEWAY_INTERFACE") - 1 + sizeof("CGI/1.1") - 1; | |
591 } | |
592 | |
593 | |
594 if (flcf->vars) { | |
595 cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module); | |
596 | |
597 var = cmcf->variables.elts; | |
598 vindex = flcf->vars->elts; | |
599 | |
600 for (i = 0; i < flcf->vars->nelts; i++) { | |
601 | |
602 value = ngx_http_get_indexed_variable(r, vindex[i]); | |
603 if (value == NULL) { | |
604 continue; | |
605 } | |
606 | |
607 if (value->text.len) { | |
608 len += 1 + 1 + var[vindex[i]].name.len + value->text.len; | |
609 } | |
610 } | |
611 } | |
612 | |
613 | |
614 part = &r->headers_in.headers.part; | |
615 header = part->elts; | |
616 | |
617 for (i = 0; /* void */; i++) { | |
618 | |
619 if (i >= part->nelts) { | |
620 if (part->next == NULL) { | |
621 break; | |
622 } | |
623 | |
624 part = part->next; | |
625 header = part->elts; | |
626 i = 0; | |
627 } | |
628 | |
629 len += ((header[i].key.len > 127) ? 4 : 1) | |
630 + ((header[i].value.len > 127) ? 4 : 1) | |
631 + 5 + header[i].key.len + header[i].value.len; | |
632 } | |
633 | |
634 | |
635 if (len > 65535) { | |
636 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, | |
637 "fastcgi: the request record is too big"); | |
638 return NGX_ERROR; | |
639 } | |
640 | |
641 | |
642 padding = 8 - len % 8; | |
643 padding = (padding == 8) ? 0 : padding; | |
644 | |
645 | |
646 size = sizeof(ngx_http_fastcgi_header_t) | |
647 + sizeof(ngx_http_fastcgi_begin_request_t) | |
648 | |
649 + sizeof(ngx_http_fastcgi_header_t) /* NGX_HTTP_FASTCGI_PARAMS */ | |
650 + len + padding | |
651 + sizeof(ngx_http_fastcgi_header_t) /* NGX_HTTP_FASTCGI_PARAMS */ | |
652 | |
653 + sizeof(ngx_http_fastcgi_header_t); /* NGX_HTTP_FASTCGI_STDIN */ | |
654 | |
655 | |
656 b = ngx_create_temp_buf(r->pool, size); | |
657 if (b == NULL) { | |
658 return NGX_ERROR; | |
659 } | |
660 | |
661 cl = ngx_alloc_chain_link(r->pool); | |
662 if (cl == NULL) { | |
663 return NGX_ERROR; | |
664 } | |
665 | |
666 cl->buf = b; | |
667 | |
668 h = (ngx_http_fastcgi_header_t *) b->pos; | |
669 | |
670 h->version = 1; | |
671 h->type = NGX_HTTP_FASTCGI_BEGIN_REQUEST; | |
672 h->request_id_hi = 0; | |
673 h->request_id_lo = 1; | |
674 h->content_length_hi = 0; | |
675 h->content_length_lo = sizeof(ngx_http_fastcgi_begin_request_t); | |
676 h->padding_length = 0; | |
677 h->reserved = 0; | |
678 | |
679 br = (ngx_http_fastcgi_begin_request_t *) | |
680 (b->pos + sizeof(ngx_http_fastcgi_header_t)); | |
681 br->role_hi = 0; | |
682 br->role_lo = NGX_HTTP_FASTCGI_RESPONDER; | |
683 br->flags = 0; /* NGX_HTTP_FASTCGI_KEEP_CONN */ | |
684 br->reserved[0] = 0; | |
685 br->reserved[1] = 0; | |
686 br->reserved[2] = 0; | |
687 br->reserved[3] = 0; | |
688 br->reserved[4] = 0; | |
689 | |
690 h = (ngx_http_fastcgi_header_t *) | |
691 (b->pos + sizeof(ngx_http_fastcgi_header_t) | |
692 + sizeof(ngx_http_fastcgi_begin_request_t)); | |
693 | |
694 h->version = 1; | |
695 h->type = NGX_HTTP_FASTCGI_PARAMS; | |
696 h->request_id_hi = 0; | |
697 h->request_id_lo = 1; | |
698 h->content_length_hi = (u_char) ((len >> 8) & 0xff); | |
699 h->content_length_lo = (u_char) (len & 0xff); | |
700 h->padding_length = (u_char) padding; | |
701 h->reserved = 0; | |
702 | |
703 b->last = b->pos + sizeof(ngx_http_fastcgi_header_t) | |
704 + sizeof(ngx_http_fastcgi_begin_request_t) | |
705 + sizeof(ngx_http_fastcgi_header_t); | |
706 | |
707 | |
708 *b->last++ = sizeof("PATH_TRANSLATED") - 1; | |
709 | |
710 len = flcf->root.len + r->uri.len + index; | |
711 if (len > 127) { | |
712 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
713 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
714 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
715 *b->last++ = (u_char) (len & 0xff); | |
716 | |
717 } else { | |
718 *b->last++ = (u_char) len; | |
719 } | |
720 | |
721 b->last = ngx_cpymem(b->last, "PATH_TRANSLATED", | |
722 sizeof("PATH_TRANSLATED") - 1); | |
723 b->last = ngx_cpymem(b->last, flcf->root.data, flcf->root.len); | |
724 b->last = ngx_cpymem(b->last, r->uri.data, r->uri.len); | |
725 | |
726 if (index) { | |
727 b->last = ngx_cpymem(b->last, flcf->index.data, index); | |
728 } | |
729 | |
730 | |
731 *b->last++ = sizeof("REQUEST_METHOD") - 1; | |
732 | |
733 if (r->upstream->method) { | |
734 *b->last++ = (u_char) | |
735 ngx_http_fastcgi_methods[r->upstream->method - 1].len; | |
736 | |
737 b->last = ngx_cpymem(b->last, "REQUEST_METHOD", | |
738 sizeof("REQUEST_METHOD") - 1); | |
739 | |
740 b->last = ngx_cpymem(b->last, | |
741 ngx_http_fastcgi_methods[r->upstream->method - 1].data, | |
742 ngx_http_fastcgi_methods[r->upstream->method - 1].len); | |
743 | |
744 } else { | |
745 len = r->method_name.len - 1; | |
746 if (len > 127) { | |
747 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
748 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
749 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
750 *b->last++ = (u_char) (len & 0xff); | |
751 | |
752 } else { | |
753 *b->last++ = (u_char) len; | |
754 } | |
755 | |
756 b->last = ngx_cpymem(b->last, "REQUEST_METHOD", | |
757 sizeof("REQUEST_METHOD") - 1); | |
758 b->last = ngx_cpymem(b->last, r->method_name.data, len); | |
759 } | |
760 | |
761 | |
762 if (r->args.len) { | |
763 *b->last++ = sizeof("QUERY_STRING") - 1; | |
764 | |
765 len = r->args.len; | |
766 if (len > 127) { | |
767 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
768 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
769 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
770 *b->last++ = (u_char) (len & 0xff); | |
771 | |
772 } else { | |
773 *b->last++ = (u_char) len; | |
774 } | |
775 | |
776 b->last = ngx_cpymem(b->last, "QUERY_STRING", | |
777 sizeof("QUERY_STRING") - 1); | |
778 b->last = ngx_cpymem(b->last, r->args.data, len); | |
779 } | |
780 | |
781 | |
782 if (r->headers_in.content_length_n > 0) { | |
783 *b->last++ = sizeof("CONTENT_LENGTH") - 1; | |
784 | |
785 len = r->headers_in.content_length->value.len; | |
786 if (len > 127) { | |
787 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
788 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
789 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
790 *b->last++ = (u_char) (len & 0xff); | |
791 | |
792 } else { | |
793 *b->last++ = (u_char) len; | |
794 } | |
795 | |
796 b->last = ngx_cpymem(b->last, "CONTENT_LENGTH", | |
797 sizeof("CONTENT_LENGTH") - 1); | |
798 b->last = ngx_cpymem(b->last, r->headers_in.content_length->value.data, | |
799 len); | |
800 } | |
801 | |
802 | |
803 if (r->headers_in.content_type) { | |
804 *b->last++ = sizeof("CONTENT_TYPE") - 1; | |
805 | |
806 len = r->headers_in.content_type->value.len; | |
807 if (len > 127) { | |
808 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
809 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
810 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
811 *b->last++ = (u_char) (len & 0xff); | |
812 | |
813 } else { | |
814 *b->last++ = (u_char) len; | |
815 } | |
816 | |
817 b->last = ngx_cpymem(b->last, "CONTENT_TYPE", | |
818 sizeof("CONTENT_TYPE") - 1); | |
819 b->last = ngx_cpymem(b->last, r->headers_in.content_type->value.data, | |
820 len); | |
821 } | |
822 | |
823 | |
824 if (flcf->params & NGX_HTTP_FASTCGI_REDIRECT_STATUS) { | |
825 *b->last++ = sizeof("REDIRECT_STATUS") - 1; | |
826 *b->last++ = sizeof("200") - 1; | |
827 b->last = ngx_cpymem(b->last, "REDIRECT_STATUS200", | |
828 sizeof("REDIRECT_STATUS200") - 1); | |
829 } | |
830 | |
831 | |
832 if (flcf->params & NGX_HTTP_FASTCGI_REQUEST_URI) { | |
833 *b->last++ = sizeof("REQUEST_URI") - 1; | |
834 | |
835 len = r->unparsed_uri.len; | |
836 if (len > 127) { | |
837 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
838 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
839 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
840 *b->last++ = (u_char) (len & 0xff); | |
841 | |
842 } else { | |
843 *b->last++ = (u_char) len; | |
844 } | |
845 | |
846 b->last = ngx_cpymem(b->last, "REQUEST_URI", sizeof("REQUEST_URI") - 1); | |
847 b->last = ngx_cpymem(b->last, r->unparsed_uri.data, len); | |
848 } | |
849 | |
850 | |
851 if (flcf->params & NGX_HTTP_FASTCGI_DOCUMENT_ROOT) { | |
852 *b->last++ = sizeof("DOCUMENT_ROOT") - 1; | |
853 | |
854 len = clcf->root.len; | |
855 if (len > 127) { | |
856 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
857 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
858 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
859 *b->last++ = (u_char) (len & 0xff); | |
860 | |
861 } else { | |
862 *b->last++ = (u_char) len; | |
863 } | |
864 | |
865 b->last = ngx_cpymem(b->last, "DOCUMENT_ROOT", | |
866 sizeof("DOCUMENT_ROOT") - 1); | |
867 b->last = ngx_cpymem(b->last, clcf->root.data, len); | |
868 } | |
869 | |
870 | |
871 if (flcf->params & NGX_HTTP_FASTCGI_SCRIPT_FILENAME) { | |
872 *b->last++ = sizeof("SCRIPT_FILENAME") - 1; | |
873 | |
874 len = flcf->root.len + r->uri.len + index; | |
875 if (len > 127) { | |
876 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
877 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
878 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
879 *b->last++ = (u_char) (len & 0xff); | |
880 | |
881 } else { | |
882 *b->last++ = (u_char) len; | |
883 } | |
884 | |
885 b->last = ngx_cpymem(b->last, "SCRIPT_FILENAME", | |
886 sizeof("SCRIPT_FILENAME") - 1); | |
887 b->last = ngx_cpymem(b->last, flcf->root.data, flcf->root.len); | |
888 b->last = ngx_cpymem(b->last, r->uri.data, r->uri.len); | |
889 | |
890 if (index) { | |
891 b->last = ngx_cpymem(b->last, flcf->index.data, index); | |
892 } | |
893 } | |
894 | |
895 | |
896 if (flcf->params & NGX_HTTP_FASTCGI_SCRIPT_NAME) { | |
897 *b->last++ = sizeof("SCRIPT_NAME") - 1; | |
898 | |
899 len = r->uri.len + index; | |
900 if (len > 127) { | |
901 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
902 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
903 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
904 *b->last++ = (u_char) (len & 0xff); | |
905 | |
906 } else { | |
907 *b->last++ = (u_char) len; | |
908 } | |
909 | |
910 b->last = ngx_cpymem(b->last, "SCRIPT_NAME", sizeof("SCRIPT_NAME") - 1); | |
911 b->last = ngx_cpymem(b->last, r->uri.data, r->uri.len); | |
912 | |
913 if (index) { | |
914 b->last = ngx_cpymem(b->last, flcf->index.data, index); | |
915 } | |
916 } | |
917 | |
918 | |
919 if (flcf->params & NGX_HTTP_FASTCGI_REMOTE_ADDR) { | |
920 *b->last++ = sizeof("REMOTE_ADDR") - 1; | |
921 *b->last++ = (u_char) (r->connection->addr_text.len); | |
922 b->last = ngx_cpymem(b->last, "REMOTE_ADDR", sizeof("REMOTE_ADDR") - 1); | |
923 b->last = ngx_cpymem(b->last, r->connection->addr_text.data, | |
924 r->connection->addr_text.len); | |
925 } | |
926 | |
927 | |
928 if (port_len) { | |
929 *b->last++ = sizeof("REMOTE_PORT") - 1; | |
930 *b->last++ = (u_char) port_len; | |
931 b->last = ngx_cpymem(b->last, "REMOTE_PORT", sizeof("REMOTE_PORT") - 1); | |
932 b->last = ngx_cpymem(b->last, port_text, port_len); | |
933 } | |
934 | |
935 | |
936 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_NAME) { | |
937 *b->last++ = sizeof("SERVER_NAME") - 1; | |
938 *b->last++ = (u_char) r->server_name.len; | |
939 b->last = ngx_cpymem(b->last, "SERVER_NAME", sizeof("SERVER_NAME") - 1); | |
940 b->last = ngx_cpymem(b->last, r->server_name.data, r->server_name.len); | |
941 } | |
942 | |
943 | |
944 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_PORT) { | |
945 *b->last++ = sizeof("SERVER_PORT") - 1; | |
946 *b->last++ = (u_char) (r->port_text->len - 1); | |
947 b->last = ngx_cpymem(b->last, "SERVER_PORT", sizeof("SERVER_PORT") - 1); | |
948 b->last = ngx_cpymem(b->last, r->port_text->data + 1, | |
949 r->port_text->len - 1); | |
950 } | |
951 | |
952 | |
953 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_ADDR) { | |
954 *b->last++ = sizeof("SERVER_ADDR") - 1; | |
955 *b->last++ = (u_char) addr_len; | |
956 b->last = ngx_cpymem(b->last, "SERVER_ADDR", sizeof("SERVER_ADDR") - 1); | |
957 b->last = ngx_cpymem(b->last, addr_text, addr_len); | |
958 } | |
959 | |
960 | |
961 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_PROTOCOL | |
962 && r->http_protocol.len) | |
963 { | |
964 *b->last++ = sizeof("SERVER_PROTOCOL") - 1; | |
965 | |
966 len = r->http_protocol.len; | |
967 if (len > 127) { | |
968 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
969 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
970 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
971 *b->last++ = (u_char) (len & 0xff); | |
972 | |
973 } else { | |
974 *b->last++ = (u_char) len; | |
975 } | |
976 | |
977 b->last = ngx_cpymem(b->last, "SERVER_PROTOCOL", | |
978 sizeof("SERVER_PROTOCOL") - 1); | |
979 b->last = ngx_cpymem(b->last, r->http_protocol.data, len); | |
980 } | |
981 | |
982 | |
983 if (flcf->params & NGX_HTTP_FASTCGI_SERVER_SOFTWARE) { | |
984 *b->last++ = sizeof("SERVER_SOFTWARE") - 1; | |
985 *b->last++ = (u_char) (sizeof(NGINX_VER) - 1); | |
986 b->last = ngx_cpymem(b->last, "SERVER_SOFTWARE", | |
987 sizeof("SERVER_SOFTWARE") - 1); | |
988 b->last = ngx_cpymem(b->last, NGINX_VER, sizeof(NGINX_VER) - 1); | |
989 } | |
990 | |
991 | |
992 if (flcf->params & NGX_HTTP_FASTCGI_GATEWAY_INTERFACE) { | |
993 *b->last++ = sizeof("GATEWAY_INTERFACE") - 1; | |
994 *b->last++ = (u_char) (sizeof("CGI/1.1") - 1); | |
995 b->last = ngx_cpymem(b->last, "GATEWAY_INTERFACE", | |
996 sizeof("GATEWAY_INTERFACE") - 1); | |
997 b->last = ngx_cpymem(b->last, "CGI/1.1", sizeof("CGI/1.1") - 1); | |
998 } | |
999 | |
1000 | |
1001 if (flcf->vars) { | |
1002 for (i = 0; i < flcf->vars->nelts; i++) { | |
1003 | |
1004 value = ngx_http_get_indexed_variable(r, vindex[i]); | |
1005 if (value == NULL) { | |
1006 continue; | |
1007 } | |
1008 | |
1009 if (value->text.len == 0) { | |
1010 continue; | |
1011 } | |
1012 | |
1013 *b->last++ = (u_char) var[vindex[i]].name.len; | |
1014 *b->last++ = (u_char) value->text.len; | |
1015 | |
1016 b->last = ngx_cpymem(b->last, var[vindex[i]].name.data, | |
1017 var[vindex[i]].name.len); | |
1018 | |
1019 b->last = ngx_cpymem(b->last, value->text.data, value->text.len); | |
1020 } | |
1021 } | |
1022 | |
1023 | |
1024 part = &r->headers_in.headers.part; | |
1025 header = part->elts; | |
1026 | |
1027 for (i = 0; /* void */; i++) { | |
1028 | |
1029 if (i >= part->nelts) { | |
1030 if (part->next == NULL) { | |
1031 break; | |
1032 } | |
1033 | |
1034 part = part->next; | |
1035 header = part->elts; | |
1036 i = 0; | |
1037 } | |
1038 | |
1039 len = 5 + header[i].key.len; | |
1040 if (len > 127) { | |
1041 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
1042 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
1043 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
1044 *b->last++ = (u_char) (len & 0xff); | |
1045 | |
1046 } else { | |
1047 *b->last++ = (u_char) len; | |
1048 } | |
1049 | |
1050 len = header[i].value.len; | |
1051 if (len > 127) { | |
1052 *b->last++ = (u_char) (((len >> 24) & 0x7f) | 0x80); | |
1053 *b->last++ = (u_char) ((len >> 16) & 0xff); | |
1054 *b->last++ = (u_char) ((len >> 8) & 0xff); | |
1055 *b->last++ = (u_char) (len & 0xff); | |
1056 | |
1057 } else { | |
1058 *b->last++ = (u_char) len; | |
1059 } | |
1060 | |
1061 b->last = ngx_cpymem(b->last, "HTTP_", sizeof("HTTP_") - 1); | |
1062 | |
1063 for (n = 0; n < header[i].key.len; n++) { | |
1064 ch = header[i].key.data[n]; | |
1065 | |
1066 if (ch >= 'a' && ch <= 'z') { | |
1067 ch &= ~0x20; | |
1068 | |
1069 } else if (ch == '-') { | |
1070 ch = '_'; | |
1071 } | |
1072 | |
1073 *b->last++ = ch; | |
1074 } | |
1075 | |
1076 b->last = ngx_cpymem(b->last, header[i].value.data, | |
1077 header[i].value.len); | |
1078 } | |
1079 | |
1080 | |
1081 if (padding) { | |
1082 ngx_memzero(b->last, padding); | |
1083 b->last += padding; | |
1084 } | |
1085 | |
1086 | |
1087 h = (ngx_http_fastcgi_header_t *) b->last; | |
1088 b->last += sizeof(ngx_http_fastcgi_header_t); | |
1089 | |
1090 h->version = 1; | |
1091 h->type = NGX_HTTP_FASTCGI_PARAMS; | |
1092 h->request_id_hi = 0; | |
1093 h->request_id_lo = 1; | |
1094 h->content_length_hi = 0; | |
1095 h->content_length_lo = 0; | |
1096 h->padding_length = 0; | |
1097 h->reserved = 0; | |
1098 | |
1099 h = (ngx_http_fastcgi_header_t *) b->last; | |
1100 b->last += sizeof(ngx_http_fastcgi_header_t); | |
1101 | |
1102 body = r->request_body->bufs; | |
1103 r->request_body->bufs = cl; | |
1104 | |
1105 #if (NGX_SUPPRESS_WARN) | |
1106 file_pos = 0; | |
1107 pos = NULL; | |
1108 #endif | |
1109 | |
1110 while (body) { | |
1111 | |
1112 if (body->buf->in_file) { | |
1113 file_pos = body->buf->file_pos; | |
1114 | |
1115 } else { | |
1116 pos = body->buf->pos; | |
1117 } | |
1118 | |
1119 next = 0; | |
1120 | |
1121 do { | |
1122 b = ngx_alloc_buf(r->pool); | |
1123 if (b == NULL) { | |
1124 return NGX_ERROR; | |
1125 } | |
1126 | |
1127 ngx_memcpy(b, body->buf, sizeof(ngx_buf_t)); | |
1128 | |
1129 if (body->buf->in_file) { | |
1130 b->file_pos = file_pos; | |
1131 file_pos += 32 * 1024; | |
1132 | |
1133 if (file_pos > body->buf->file_last) { | |
1134 file_pos = body->buf->file_last; | |
1135 next = 1; | |
1136 } | |
1137 | |
1138 b->file_last = file_pos; | |
1139 len = (ngx_uint_t) (file_pos - b->file_pos); | |
1140 | |
1141 } else { | |
1142 b->pos = pos; | |
1143 pos += 32 * 1024; | |
1144 | |
1145 if (pos > body->buf->last) { | |
1146 pos = body->buf->last; | |
1147 next = 1; | |
1148 } | |
1149 | |
1150 b->last = pos; | |
1151 len = (ngx_uint_t) (pos - b->pos); | |
1152 } | |
1153 | |
1154 padding = 8 - len % 8; | |
1155 padding = (padding == 8) ? 0 : padding; | |
1156 | |
1157 h->version = 1; | |
1158 h->type = NGX_HTTP_FASTCGI_STDIN; | |
1159 h->request_id_hi = 0; | |
1160 h->request_id_lo = 1; | |
1161 h->content_length_hi = (u_char) ((len >> 8) & 0xff); | |
1162 h->content_length_lo = (u_char) (len & 0xff); | |
1163 h->padding_length = (u_char) padding; | |
1164 h->reserved = 0; | |
1165 | |
1166 cl->next = ngx_alloc_chain_link(r->pool); | |
1167 if (cl->next == NULL) { | |
1168 return NGX_ERROR; | |
1169 } | |
1170 | |
1171 cl = cl->next; | |
1172 cl->buf = b; | |
1173 | |
1174 b = ngx_create_temp_buf(r->pool, sizeof(ngx_http_fastcgi_header_t) | |
1175 + padding); | |
1176 if (b == NULL) { | |
1177 return NGX_ERROR; | |
1178 } | |
1179 | |
1180 if (padding) { | |
1181 ngx_memzero(b->last, padding); | |
1182 b->last += padding; | |
1183 } | |
1184 | |
1185 h = (ngx_http_fastcgi_header_t *) b->last; | |
1186 b->last += sizeof(ngx_http_fastcgi_header_t); | |
1187 | |
1188 cl->next = ngx_alloc_chain_link(r->pool); | |
1189 if (cl->next == NULL) { | |
1190 return NGX_ERROR; | |
1191 } | |
1192 | |
1193 cl = cl->next; | |
1194 cl->buf = b; | |
1195 | |
1196 } while (!next); | |
1197 | |
1198 body = body->next; | |
1199 } | |
1200 | |
1201 h->version = 1; | |
1202 h->type = NGX_HTTP_FASTCGI_STDIN; | |
1203 h->request_id_hi = 0; | |
1204 h->request_id_lo = 1; | |
1205 h->content_length_hi = 0; | |
1206 h->content_length_lo = 0; | |
1207 h->padding_length = 0; | |
1208 h->reserved = 0; | |
1209 | |
1210 cl->next = NULL; | |
1211 | |
1212 return NGX_OK; | |
1213 } | |
1214 | |
1215 | |
1216 static ngx_int_t | |
1217 ngx_http_fastcgi_reinit_request(ngx_http_request_t *r) | |
1218 { | |
1219 ngx_http_fastcgi_ctx_t *f; | |
1220 | |
1221 f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module); | |
1222 | |
1223 if (f == NULL) { | |
1224 return NGX_OK; | |
1225 } | |
1226 | |
1227 f->state = ngx_http_fastcgi_st_version; | |
1228 f->header = 0; | |
1229 | |
1230 ngx_memzero(&f->upstream->headers_in, | |
1231 sizeof(ngx_http_fastcgi_headers_in_t)); | |
1232 | |
1233 if (f->upstream->headers_in.headers.part.elts) { | |
1234 if (ngx_list_init(&f->upstream->headers_in.headers, r->pool, 8, | |
1235 sizeof(ngx_table_elt_t)) == NGX_ERROR) | |
1236 { | |
1237 return NGX_ERROR; | |
1238 } | |
1239 } | |
1240 | |
1241 return NGX_OK; | |
1242 } | |
1243 | |
1244 | |
1245 static ngx_int_t ngx_http_fastcgi_process_header(ngx_http_request_t *r) | |
1246 { | |
1247 u_char *start, *last; | |
1248 ngx_str_t *status_line, line; | |
1249 ngx_int_t rc, status; | |
1250 ngx_uint_t i; | |
1251 ngx_table_elt_t *h; | |
1252 ngx_http_upstream_t *u; | |
1253 ngx_http_fastcgi_ctx_t *f; | |
1254 | |
1255 f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module); | |
1256 | |
1257 if (f == NULL) { | |
1258 f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t)); | |
1259 if (f == NULL) { | |
1260 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1261 } | |
1262 | |
1263 ngx_http_set_ctx(r, f, ngx_http_fastcgi_module); | |
1264 | |
1265 f->upstream = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_upstream_t)); | |
1266 if (f->upstream == NULL) { | |
1267 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1268 } | |
1269 | |
1270 if (ngx_list_init(&f->upstream->headers_in.headers, r->pool, 8, | |
1271 sizeof(ngx_table_elt_t)) == NGX_ERROR) | |
1272 { | |
1273 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1274 } | |
1275 } | |
1276 | |
1277 u = r->upstream; | |
1278 | |
1279 for ( ;; ) { | |
1280 | |
1281 if (f->state < ngx_http_fastcgi_st_data) { | |
1282 | |
1283 f->pos = u->header_in.pos; | |
1284 f->last = u->header_in.last; | |
1285 | |
1286 rc = ngx_http_fastcgi_process_record(r, f); | |
1287 | |
1288 u->header_in.pos = f->pos; | |
1289 u->header_in.last = f->last; | |
1290 | |
1291 if (rc == NGX_AGAIN) { | |
1292 return NGX_AGAIN; | |
1293 } | |
1294 | |
1295 if (rc == NGX_ERROR) { | |
1296 return NGX_HTTP_UPSTREAM_INVALID_HEADER; | |
1297 } | |
1298 | |
1299 if (f->type != NGX_HTTP_FASTCGI_STDOUT | |
1300 && f->type != NGX_HTTP_FASTCGI_STDERR) | |
1301 { | |
1302 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1303 "upstream sent unexpected FastCGI record: %d", | |
1304 f->type); | |
1305 | |
1306 return NGX_HTTP_UPSTREAM_INVALID_HEADER; | |
1307 } | |
1308 | |
1309 if (f->type == NGX_HTTP_FASTCGI_STDOUT && f->length == 0) { | |
1310 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1311 "upstream closed prematurely FastCGI stdout"); | |
1312 | |
1313 return NGX_HTTP_UPSTREAM_INVALID_HEADER; | |
1314 } | |
1315 } | |
1316 | |
1317 if (f->state == ngx_http_fastcgi_st_padding) { | |
1318 | |
1319 if (u->header_in.pos + f->padding < u->header_in.last) { | |
1320 f->state = ngx_http_fastcgi_st_version; | |
1321 u->header_in.pos += f->padding; | |
1322 | |
1323 continue; | |
1324 } | |
1325 | |
1326 if (u->header_in.pos + f->padding == u->header_in.last) { | |
1327 f->state = ngx_http_fastcgi_st_version; | |
1328 u->header_in.pos = u->header_in.last; | |
1329 | |
1330 return NGX_AGAIN; | |
1331 } | |
1332 | |
1333 f->padding -= u->header_in.last - u->header_in.pos; | |
1334 u->header_in.pos = u->header_in.last; | |
1335 | |
1336 return NGX_AGAIN; | |
1337 } | |
1338 | |
1339 | |
1340 /* f->state == ngx_http_fastcgi_st_data */ | |
1341 | |
1342 if (f->type == NGX_HTTP_FASTCGI_STDERR) { | |
1343 | |
1344 if (f->header) { | |
1345 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, | |
1346 "upstream split a header in FastCGI records"); | |
1347 | |
1348 return NGX_HTTP_UPSTREAM_INVALID_HEADER; | |
1349 } | |
1350 | |
1351 if (f->length) { | |
1352 line.data = u->header_in.pos; | |
1353 | |
1354 if (u->header_in.pos + f->length <= u->header_in.last) { | |
1355 line.len = f->length; | |
1356 u->header_in.pos += f->length; | |
1357 f->length = 0; | |
1358 f->state = ngx_http_fastcgi_st_padding; | |
1359 | |
1360 } else { | |
1361 line.len = u->header_in.last - u->header_in.pos; | |
1362 f->length -= u->header_in.last - u->header_in.pos; | |
1363 u->header_in.pos = u->header_in.last; | |
1364 } | |
1365 | |
1366 while (line.data[line.len - 1] == LF | |
1367 || line.data[line.len - 1] == CR | |
1368 || line.data[line.len - 1] == '.' | |
1369 || line.data[line.len - 1] == ' ') | |
1370 { | |
1371 line.len--; | |
1372 } | |
1373 | |
1374 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1375 "FastCGI sent in stderr: \"%V\"", &line); | |
1376 | |
1377 if (u->header_in.pos == u->header_in.last) { | |
1378 return NGX_AGAIN; | |
1379 } | |
1380 | |
1381 } else { | |
1382 f->state = ngx_http_fastcgi_st_version; | |
1383 } | |
1384 | |
1385 continue; | |
1386 } | |
1387 | |
1388 | |
1389 /* f->type == NGX_HTTP_FASTCGI_STDOUT */ | |
1390 | |
1391 start = u->header_in.pos; | |
1392 | |
1393 if (u->header_in.pos + f->length < u->header_in.last) { | |
1394 | |
1395 /* | |
1396 * set u->header_in.last to the end of the FastCGI record data | |
1397 * for ngx_http_parse_header_line() | |
1398 */ | |
1399 | |
1400 last = u->header_in.last; | |
1401 u->header_in.last = u->header_in.pos + f->length; | |
1402 | |
1403 } else { | |
1404 last = NULL; | |
1405 } | |
1406 | |
1407 f->header = 1; | |
1408 | |
1409 for ( ;; ) { | |
1410 | |
1411 rc = ngx_http_parse_header_line(r, &u->header_in); | |
1412 | |
1413 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1414 "http fastcgi parser: %d", rc); | |
1415 | |
1416 if (rc == NGX_AGAIN) { | |
1417 break; | |
1418 } | |
1419 | |
1420 if (rc == NGX_OK) { | |
1421 | |
1422 /* a header line has been parsed successfully */ | |
1423 | |
1424 h = ngx_list_push(&f->upstream->headers_in.headers); | |
1425 if (h == NULL) { | |
1426 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1427 } | |
1428 | |
1429 h->key.len = r->header_name_end - r->header_name_start; | |
1430 h->value.len = r->header_end - r->header_start; | |
1431 | |
1432 h->key.data = ngx_palloc(r->pool, | |
1433 h->key.len + 1 + h->value.len + 1); | |
1434 if (h->key.data == NULL) { | |
1435 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1436 } | |
1437 | |
1438 h->value.data = h->key.data + h->key.len + 1; | |
1439 | |
1440 ngx_cpystrn(h->key.data, r->header_name_start, h->key.len + 1); | |
1441 ngx_cpystrn(h->value.data, r->header_start, h->value.len + 1); | |
1442 | |
1443 for (i = 0; ngx_http_fastcgi_headers_in[i].name.len != 0; i++) { | |
1444 if (ngx_http_fastcgi_headers_in[i].name.len != h->key.len) { | |
1445 continue; | |
1446 } | |
1447 | |
1448 if (ngx_strcasecmp(ngx_http_fastcgi_headers_in[i].name.data, | |
1449 h->key.data) == 0) | |
1450 { | |
1451 *((ngx_table_elt_t **) | |
1452 ((char *) &f->upstream->headers_in | |
1453 + ngx_http_fastcgi_headers_in[i].offset)) = h; | |
1454 break; | |
1455 } | |
1456 } | |
1457 | |
1458 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1459 "http fastcgi header: \"%V: %V\"", | |
1460 &h->key, &h->value); | |
1461 | |
1462 continue; | |
1463 } | |
1464 | |
1465 if (rc == NGX_HTTP_PARSE_HEADER_DONE) { | |
1466 | |
1467 /* a whole header has been parsed successfully */ | |
1468 | |
1469 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1470 "http fastcgi header done"); | |
1471 | |
1472 if (f->upstream->headers_in.status) { | |
1473 status_line = &f->upstream->headers_in.status->value; | |
1474 | |
1475 status = ngx_atoi(status_line->data, 3); | |
1476 | |
1477 if (status == NGX_ERROR) { | |
1478 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1479 } | |
1480 | |
1481 r->headers_out.status = status; | |
1482 r->headers_out.status_line = *status_line; | |
1483 | |
1484 } else { | |
1485 r->headers_out.status = 200; | |
1486 r->headers_out.status_line.len = sizeof("200 OK") - 1; | |
1487 r->headers_out.status_line.data = (u_char *) "200 OK"; | |
1488 } | |
1489 | |
1490 u->state->status = r->headers_out.status; | |
1491 #if 0 | |
1492 if (u->cachable) { | |
1493 u->cachable = ngx_http_upstream_is_cachable(r); | |
1494 } | |
1495 #endif | |
1496 | |
1497 break; | |
1498 } | |
1499 | |
1500 /* there was error while a header line parsing */ | |
1501 | |
1502 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1503 ngx_http_upstream_header_errors[rc | |
1504 - NGX_HTTP_PARSE_HEADER_ERROR]); | |
1505 | |
1506 return NGX_HTTP_UPSTREAM_INVALID_HEADER; | |
1507 | |
1508 } | |
1509 | |
1510 if (last) { | |
1511 u->header_in.last = last; | |
1512 } | |
1513 | |
1514 f->length -= u->header_in.pos - start; | |
1515 | |
1516 if (rc == NGX_AGAIN) { | |
1517 if (u->header_in.pos == u->header_in.last) { | |
1518 return NGX_AGAIN; | |
1519 } | |
1520 | |
1521 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0, | |
1522 "upstream split a header in FastCGI records"); | |
1523 | |
1524 return NGX_HTTP_UPSTREAM_INVALID_HEADER; | |
1525 } | |
1526 | |
1527 if (f->length == 0) { | |
1528 if (f->padding) { | |
1529 f->state = ngx_http_fastcgi_st_padding; | |
1530 } else { | |
1531 f->state = ngx_http_fastcgi_st_version; | |
1532 } | |
1533 } | |
1534 | |
1535 return NGX_OK; | |
1536 } | |
1537 } | |
1538 | |
1539 | |
1540 static ngx_int_t | |
1541 ngx_http_fastcgi_send_header(ngx_http_request_t *r) | |
1542 { | |
1543 ngx_uint_t i; | |
1544 ngx_list_part_t *part; | |
1545 ngx_table_elt_t *ho, *h; | |
1546 ngx_http_fastcgi_ctx_t *f; | |
1547 ngx_http_fastcgi_headers_in_t *headers_in; | |
1548 | |
1549 f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module); | |
1550 | |
1551 headers_in = &f->upstream->headers_in; | |
1552 part = &headers_in->headers.part; | |
1553 h = part->elts; | |
1554 | |
1555 for (i = 0; /* void */; i++) { | |
1556 | |
1557 if (i >= part->nelts) { | |
1558 if (part->next == NULL) { | |
1559 break; | |
1560 } | |
1561 | |
1562 part = part->next; | |
1563 h = part->elts; | |
1564 i = 0; | |
1565 } | |
1566 | |
1567 /* ignore some headers */ | |
1568 | |
1569 if (&h[i] == headers_in->status) { | |
1570 continue; | |
1571 } | |
1572 | |
1573 | |
1574 if (&h[i] == headers_in->x_powered_by | |
1575 && !r->upstream->conf->x_powered_by) | |
1576 { | |
1577 continue; | |
1578 } | |
1579 | |
1580 | |
1581 /* "Content-Type" is handled specially */ | |
1582 | |
1583 if (&h[i] == headers_in->content_type) { | |
1584 r->headers_out.content_type = &h[i]; | |
1585 r->headers_out.content_type->key.len = 0; | |
1586 continue; | |
1587 } | |
1588 | |
1589 | |
1590 /* copy some header pointers and set up r->headers_out */ | |
1591 | |
1592 ho = ngx_list_push(&r->headers_out.headers); | |
1593 if (ho == NULL) { | |
1594 return NGX_HTTP_INTERNAL_SERVER_ERROR; | |
1595 } | |
1596 | |
1597 *ho = h[i]; | |
1598 | |
1599 #if (NGX_HTTP_GZIP) | |
1600 if (&h[i] == headers_in->content_encoding) { | |
1601 r->headers_out.content_encoding = ho; | |
1602 continue; | |
1603 } | |
1604 #endif | |
1605 | |
1606 if (&h[i] == headers_in->content_length) { | |
1607 r->headers_out.content_length = ho; | |
1608 r->headers_out.content_length_n = ngx_atoi(ho->value.data, | |
1609 ho->value.len); | |
1610 continue; | |
1611 } | |
1612 } | |
1613 | |
1614 return ngx_http_send_header(r); | |
1615 } | |
1616 | |
1617 | |
1618 static ngx_int_t | |
1619 ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf) | |
1620 { | |
1621 ngx_int_t rc; | |
1622 ngx_buf_t *b, **prev; | |
1623 ngx_str_t line; | |
1624 ngx_chain_t *cl; | |
1625 ngx_http_request_t *r; | |
1626 ngx_http_fastcgi_ctx_t *f; | |
1627 | |
1628 if (buf->pos == buf->last) { | |
1629 return NGX_OK; | |
1630 } | |
1631 | |
1632 r = p->input_ctx; | |
1633 f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module); | |
1634 | |
1635 b = NULL; | |
1636 prev = &buf->shadow; | |
1637 | |
1638 f->pos = buf->pos; | |
1639 f->last = buf->last; | |
1640 | |
1641 for ( ;; ) { | |
1642 if (f->state < ngx_http_fastcgi_st_data) { | |
1643 | |
1644 rc = ngx_http_fastcgi_process_record(r, f); | |
1645 | |
1646 if (rc == NGX_AGAIN) { | |
1647 break; | |
1648 } | |
1649 | |
1650 if (rc == NGX_ERROR) { | |
1651 return NGX_ERROR; | |
1652 } | |
1653 | |
1654 if (f->type == NGX_HTTP_FASTCGI_STDOUT && f->length == 0) { | |
1655 f->state = ngx_http_fastcgi_st_version; | |
1656 p->upstream_done = 1; | |
1657 | |
1658 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, p->log, 0, | |
1659 "http fastcgi closed stdout"); | |
1660 | |
1661 continue; | |
1662 } | |
1663 | |
1664 if (f->type == NGX_HTTP_FASTCGI_END_REQUEST) { | |
1665 f->state = ngx_http_fastcgi_st_version; | |
1666 p->upstream_done = 1; | |
1667 | |
1668 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, p->log, 0, | |
1669 "http fastcgi sent end request"); | |
1670 | |
1671 break; | |
1672 } | |
1673 } | |
1674 | |
1675 | |
1676 if (f->state == ngx_http_fastcgi_st_padding) { | |
1677 | |
1678 if (f->pos + f->padding < f->last) { | |
1679 f->state = ngx_http_fastcgi_st_version; | |
1680 f->pos += f->padding; | |
1681 | |
1682 continue; | |
1683 } | |
1684 | |
1685 if (f->pos + f->padding == f->last) { | |
1686 f->state = ngx_http_fastcgi_st_version; | |
1687 | |
1688 break; | |
1689 } | |
1690 | |
1691 f->padding -= f->last - f->pos; | |
1692 | |
1693 break; | |
1694 } | |
1695 | |
1696 | |
1697 /* f->state == ngx_http_fastcgi_st_data */ | |
1698 | |
1699 if (f->type == NGX_HTTP_FASTCGI_STDERR) { | |
1700 | |
1701 if (f->length) { | |
1702 line.data = f->pos; | |
1703 | |
1704 if (f->pos + f->length <= f->last) { | |
1705 line.len = f->length; | |
1706 f->pos += f->length; | |
1707 f->length = 0; | |
1708 f->state = ngx_http_fastcgi_st_padding; | |
1709 | |
1710 } else { | |
1711 line.len = f->last - f->pos; | |
1712 f->length -= f->last - f->pos; | |
1713 f->pos = f->last; | |
1714 } | |
1715 | |
1716 while (line.data[line.len - 1] == LF | |
1717 || line.data[line.len - 1] == CR | |
1718 || line.data[line.len - 1] == '.' | |
1719 || line.data[line.len - 1] == ' ') | |
1720 { | |
1721 line.len--; | |
1722 } | |
1723 | |
1724 ngx_log_error(NGX_LOG_ERR, p->log, 0, | |
1725 "FastCGI sent in stderr: \"%V\"", &line); | |
1726 | |
1727 if (f->pos == f->last) { | |
1728 break; | |
1729 } | |
1730 | |
1731 } else { | |
1732 f->state = ngx_http_fastcgi_st_version; | |
1733 } | |
1734 | |
1735 continue; | |
1736 } | |
1737 | |
1738 | |
1739 /* f->type == NGX_HTTP_FASTCGI_STDOUT */ | |
1740 | |
1741 if (p->free) { | |
1742 b = p->free->buf; | |
1743 p->free = p->free->next; | |
1744 | |
1745 } else { | |
1746 b = ngx_alloc_buf(p->pool); | |
1747 if (b == NULL) { | |
1748 return NGX_ERROR; | |
1749 } | |
1750 } | |
1751 | |
1752 ngx_memzero(b, sizeof(ngx_buf_t)); | |
1753 | |
1754 b->pos = f->pos; | |
1755 b->start = buf->start; | |
1756 b->end = buf->end; | |
1757 b->tag = p->tag; | |
1758 b->temporary = 1; | |
1759 b->recycled = 1; | |
1760 | |
1761 *prev = b; | |
1762 prev = &b->shadow; | |
1763 | |
1764 cl = ngx_alloc_chain_link(p->pool); | |
1765 if (cl == NULL) { | |
1766 return NGX_ERROR; | |
1767 } | |
1768 | |
1769 cl->buf = b; | |
1770 cl->next = NULL; | |
1771 | |
1772 if (p->in) { | |
1773 *p->last_in = cl; | |
1774 } else { | |
1775 p->in = cl; | |
1776 } | |
1777 p->last_in = &cl->next; | |
1778 | |
1779 | |
1780 /* STUB */ b->num = buf->num; | |
1781 | |
1782 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, p->log, 0, "input buf #%d", b->num); | |
1783 | |
1784 | |
1785 if (f->pos + f->length < f->last) { | |
1786 | |
1787 if (f->padding) { | |
1788 f->state = ngx_http_fastcgi_st_padding; | |
1789 } else { | |
1790 f->state = ngx_http_fastcgi_st_version; | |
1791 } | |
1792 | |
1793 f->pos += f->length; | |
1794 b->last = f->pos; | |
1795 | |
1796 continue; | |
1797 } | |
1798 | |
1799 if (f->pos + f->length == f->last) { | |
1800 | |
1801 if (f->padding) { | |
1802 f->state = ngx_http_fastcgi_st_padding; | |
1803 } else { | |
1804 f->state = ngx_http_fastcgi_st_version; | |
1805 } | |
1806 | |
1807 b->last = f->last; | |
1808 | |
1809 break; | |
1810 } | |
1811 | |
1812 f->length -= f->last - f->pos; | |
1813 | |
1814 b->last = f->last; | |
1815 | |
1816 break; | |
1817 | |
1818 } | |
1819 | |
1820 if (b) { | |
1821 b->shadow = buf; | |
1822 b->last_shadow = 1; | |
1823 | |
1824 return NGX_OK; | |
1825 } | |
1826 | |
1827 /* there is no data record in the buf, add it to free chain */ | |
1828 | |
1829 if (ngx_event_pipe_add_free_buf(p, buf) != NGX_OK) { | |
1830 return NGX_ERROR; | |
1831 } | |
1832 | |
1833 return NGX_OK; | |
1834 } | |
1835 | |
1836 | |
1837 static ngx_int_t | |
1838 ngx_http_fastcgi_process_record(ngx_http_request_t *r, | |
1839 ngx_http_fastcgi_ctx_t *f) | |
1840 { | |
1841 u_char ch, *p; | |
1842 ngx_http_fastcgi_state_e state; | |
1843 | |
1844 state = f->state; | |
1845 | |
1846 for (p = f->pos; p < f->last; p++) { | |
1847 | |
1848 ch = *p; | |
1849 | |
1850 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1851 "http fastcgi record byte: %02Xd", ch); | |
1852 | |
1853 switch (state) { | |
1854 | |
1855 case ngx_http_fastcgi_st_version: | |
1856 if (ch != 1) { | |
1857 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1858 "upstream sent unsupported FastCGI " | |
1859 "protocol version: %d", ch); | |
1860 return NGX_ERROR; | |
1861 } | |
1862 state = ngx_http_fastcgi_st_type; | |
1863 break; | |
1864 | |
1865 case ngx_http_fastcgi_st_type: | |
1866 switch (ch) { | |
1867 case NGX_HTTP_FASTCGI_STDOUT: | |
1868 case NGX_HTTP_FASTCGI_STDERR: | |
1869 case NGX_HTTP_FASTCGI_END_REQUEST: | |
1870 f->type = (ngx_uint_t) ch; | |
1871 break; | |
1872 default: | |
1873 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1874 "upstream sent invalid FastCGI " | |
1875 "record type: %d", ch); | |
1876 return NGX_ERROR; | |
1877 | |
1878 } | |
1879 state = ngx_http_fastcgi_st_request_id_hi; | |
1880 break; | |
1881 | |
1882 /* we support the single request per connection */ | |
1883 | |
1884 case ngx_http_fastcgi_st_request_id_hi: | |
1885 if (ch != 0) { | |
1886 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1887 "upstream sent unexpected FastCGI " | |
1888 "request id high byte: %d", ch); | |
1889 return NGX_ERROR; | |
1890 } | |
1891 state = ngx_http_fastcgi_st_request_id_lo; | |
1892 break; | |
1893 | |
1894 case ngx_http_fastcgi_st_request_id_lo: | |
1895 if (ch != 1) { | |
1896 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, | |
1897 "upstream sent unexpected FastCGI " | |
1898 "request id low byte: %d", ch); | |
1899 return NGX_ERROR; | |
1900 } | |
1901 state = ngx_http_fastcgi_st_content_length_hi; | |
1902 break; | |
1903 | |
1904 case ngx_http_fastcgi_st_content_length_hi: | |
1905 f->length = ch << 8; | |
1906 state = ngx_http_fastcgi_st_content_length_lo; | |
1907 break; | |
1908 | |
1909 case ngx_http_fastcgi_st_content_length_lo: | |
1910 f->length |= (size_t) ch; | |
1911 state = ngx_http_fastcgi_st_padding_length; | |
1912 break; | |
1913 | |
1914 case ngx_http_fastcgi_st_padding_length: | |
1915 f->padding = (size_t) ch; | |
1916 state = ngx_http_fastcgi_st_reserved; | |
1917 break; | |
1918 | |
1919 case ngx_http_fastcgi_st_reserved: | |
1920 state = ngx_http_fastcgi_st_data; | |
1921 | |
1922 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1923 "http fastcgi record length: %z", f->length); | |
1924 | |
1925 f->pos = p + 1; | |
1926 f->state = state; | |
1927 | |
1928 return NGX_OK; | |
1929 | |
1930 /* suppress warning */ | |
1931 case ngx_http_fastcgi_st_data: | |
1932 case ngx_http_fastcgi_st_padding: | |
1933 break; | |
1934 } | |
1935 } | |
1936 | |
1937 f->pos = p + 1; | |
1938 f->state = state; | |
1939 | |
1940 return NGX_AGAIN; | |
1941 } | |
1942 | |
1943 | |
1944 static void | |
1945 ngx_http_fastcgi_abort_request(ngx_http_request_t *r) | |
1946 { | |
1947 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1948 "abort http fastcgi request"); | |
1949 | |
1950 return; | |
1951 } | |
1952 | |
1953 | |
1954 static void | |
1955 ngx_http_fastcgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc) | |
1956 { | |
1957 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, | |
1958 "finalize http fastcgi request"); | |
1959 | |
1960 return; | |
1961 } | |
1962 | |
1963 | |
1964 static char * | |
1965 ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) | |
1966 { | |
1967 ngx_http_fastcgi_loc_conf_t *lcf = conf; | |
1968 | |
1969 ngx_str_t *value; | |
1970 ngx_inet_upstream_t inet_upstream; | |
1971 ngx_http_core_loc_conf_t *clcf; | |
1972 #if (NGX_HAVE_UNIX_DOMAIN) | |
1973 ngx_unix_domain_upstream_t unix_upstream; | |
1974 #endif | |
1975 | |
1976 value = cf->args->elts; | |
1977 | |
1978 if (ngx_strncasecmp(value[1].data, "unix:", 5) == 0) { | |
1979 | |
1980 #if (NGX_HAVE_UNIX_DOMAIN) | |
1981 | |
1982 ngx_memzero(&unix_upstream, sizeof(ngx_unix_domain_upstream_t)); | |
1983 | |
1984 unix_upstream.name = value[1]; | |
1985 unix_upstream.url = value[1]; | |
1986 | |
1987 lcf->peers = ngx_unix_upstream_parse(cf, &unix_upstream); | |
1988 if (lcf->peers == NULL) { | |
1989 return NGX_CONF_ERROR; | |
1990 } | |
1991 | |
1992 #else | |
1993 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
1994 "the unix domain sockets are not supported " | |
1995 "on this platform"); | |
1996 return NGX_CONF_ERROR; | |
1997 | |
1998 #endif | |
1999 | |
2000 } else { | |
2001 ngx_memzero(&inet_upstream, sizeof(ngx_inet_upstream_t)); | |
2002 | |
2003 inet_upstream.name = value[1]; | |
2004 inet_upstream.url = value[1]; | |
2005 | |
2006 lcf->peers = ngx_inet_upstream_parse(cf, &inet_upstream); | |
2007 if (lcf->peers == NULL) { | |
2008 return NGX_CONF_ERROR; | |
2009 } | |
2010 } | |
2011 | |
2012 clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module); | |
2013 | |
2014 clcf->handler = ngx_http_fastcgi_handler; | |
2015 | |
2016 #if (NGX_PCRE) | |
2017 lcf->location = clcf->regex ? &ngx_http_fastcgi_uri : &clcf->name; | |
2018 #else | |
2019 lcf->location = &clcf->name; | |
2020 #endif | |
2021 | |
2022 if (clcf->name.data[clcf->name.len - 1] == '/') { | |
2023 clcf->auto_redirect = 1; | |
2024 } | |
2025 | |
2026 return NGX_CONF_OK; | |
2027 } | |
2028 | |
2029 | |
2030 static char * | |
2031 ngx_http_fastcgi_set_var(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) | |
2032 { | |
2033 ngx_http_fastcgi_loc_conf_t *lcf = conf; | |
2034 | |
2035 ngx_uint_t i, *index; | |
2036 ngx_str_t *value; | |
2037 ngx_http_variable_t *var; | |
2038 ngx_http_core_main_conf_t *cmcf; | |
2039 | |
2040 if (lcf->vars == NULL) { | |
2041 lcf->vars = ngx_array_create(cf->pool, 4, | |
2042 sizeof(ngx_http_variable_t *)); | |
2043 if (lcf->vars == NULL) { | |
2044 return NGX_CONF_ERROR; | |
2045 } | |
2046 } | |
2047 | |
2048 cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module); | |
2049 | |
2050 value = cf->args->elts; | |
2051 | |
2052 var = cmcf->variables.elts; | |
2053 for (i = 0; i < cmcf->variables.nelts; i++) { | |
2054 if (ngx_strcasecmp(var[i].name.data, value[1].data) == 0) { | |
2055 | |
2056 index = ngx_array_push(lcf->vars); | |
2057 if (index == NULL) { | |
2058 return NGX_CONF_ERROR; | |
2059 } | |
2060 | |
2061 *index = var[i].index; | |
2062 return NGX_CONF_OK; | |
2063 } | |
2064 } | |
2065 | |
2066 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2067 "unknown variable name \"%V\"", &value[1]); | |
2068 return NGX_CONF_ERROR; | |
2069 } | |
2070 | |
2071 | |
2072 static char * | |
2073 ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post, void *data) | |
2074 { | |
2075 #if (NGX_FREEBSD) | |
2076 ssize_t *np = data; | |
2077 | |
2078 if (*np >= ngx_freebsd_net_inet_tcp_sendspace) { | |
2079 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2080 "\"fastcgi_send_lowat\" must be less than %d " | |
2081 "(sysctl net.inet.tcp.sendspace)", | |
2082 ngx_freebsd_net_inet_tcp_sendspace); | |
2083 | |
2084 return NGX_CONF_ERROR; | |
2085 } | |
2086 | |
2087 #elif !(NGX_HAVE_SO_SNDLOWAT) | |
2088 ssize_t *np = data; | |
2089 | |
2090 ngx_conf_log_error(NGX_LOG_WARN, cf, 0, | |
2091 "\"fastcgi_send_lowat\" is not supported, ignored"); | |
2092 | |
2093 *np = 0; | |
2094 | |
2095 #endif | |
2096 | |
2097 return NGX_CONF_OK; | |
2098 } | |
2099 | |
2100 | |
2101 static void * | |
2102 ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf) | |
2103 { | |
2104 ngx_http_fastcgi_loc_conf_t *conf; | |
2105 | |
2106 conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_loc_conf_t)); | |
2107 if (conf == NULL) { | |
2108 return NGX_CONF_ERROR; | |
2109 } | |
2110 | |
2111 /* | |
2112 * set by ngx_pcalloc(): | |
2113 * | |
2114 * conf->upstream.bufs.num = 0; | |
2115 * conf->upstream.path = NULL; | |
2116 * conf->upstream.next_upstream = 0; | |
2117 * conf->upstream.temp_path = NULL; | |
2118 * conf->params = 0; | |
2119 * conf->root.len = 0; | |
2120 * conf->root.data = NULL; | |
2121 * conf->index.len = 0; | |
2122 * conf->index.data = NULL; | |
2123 * conf->location = NULL; | |
2124 */ | |
2125 | |
2126 conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC; | |
2127 conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC; | |
2128 conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE; | |
2129 | |
2130 conf->upstream.header_buffer_size = NGX_CONF_UNSET_SIZE; | |
2131 conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC; | |
2132 conf->upstream.busy_buffers_size = NGX_CONF_UNSET_SIZE; | |
2133 | |
2134 conf->upstream.max_temp_file_size = NGX_CONF_UNSET_SIZE; | |
2135 conf->upstream.temp_file_write_size = NGX_CONF_UNSET_SIZE; | |
2136 | |
2137 conf->upstream.redirect_errors = NGX_CONF_UNSET; | |
2138 conf->upstream.x_powered_by = NGX_CONF_UNSET; | |
2139 | |
2140 /* "fastcgi_cyclic_temp_file" is disabled */ | |
2141 conf->upstream.cyclic_temp_file = 0; | |
2142 | |
2143 return conf; | |
2144 } | |
2145 | |
2146 | |
2147 static char * | |
2148 ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child) | |
2149 { | |
2150 ngx_http_fastcgi_loc_conf_t *prev = parent; | |
2151 ngx_http_fastcgi_loc_conf_t *conf = child; | |
2152 | |
2153 size_t size; | |
2154 | |
2155 ngx_conf_merge_msec_value(conf->upstream.connect_timeout, | |
2156 prev->upstream.connect_timeout, 60000); | |
2157 ngx_conf_merge_msec_value(conf->upstream.send_timeout, | |
2158 prev->upstream.send_timeout, 60000); | |
2159 ngx_conf_merge_size_value(conf->upstream.send_lowat, | |
2160 prev->upstream.send_lowat, 0); | |
2161 | |
2162 ngx_conf_merge_msec_value(conf->upstream.read_timeout, | |
2163 prev->upstream.read_timeout, 60000); | |
2164 | |
2165 ngx_conf_merge_msec_value(conf->upstream.redirect_errors, | |
2166 prev->upstream.redirect_errors, 0); | |
2167 | |
2168 ngx_conf_merge_msec_value(conf->upstream.x_powered_by, | |
2169 prev->upstream.x_powered_by, 1); | |
2170 | |
2171 | |
2172 ngx_conf_merge_size_value(conf->upstream.header_buffer_size, | |
2173 prev->upstream.header_buffer_size, | |
2174 (size_t) ngx_pagesize); | |
2175 | |
2176 ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs, | |
2177 8, ngx_pagesize); | |
2178 | |
2179 if (conf->upstream.bufs.num < 2) { | |
2180 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2181 "there must be at least 2 \"fastcgi_buffers\""); | |
2182 return NGX_CONF_ERROR; | |
2183 } | |
2184 | |
2185 | |
2186 size = conf->upstream.header_buffer_size; | |
2187 if (size < conf->upstream.bufs.size) { | |
2188 size = conf->upstream.bufs.size; | |
2189 } | |
2190 | |
2191 | |
2192 ngx_conf_merge_size_value(conf->upstream.busy_buffers_size, | |
2193 prev->upstream.busy_buffers_size, | |
2194 NGX_CONF_UNSET_SIZE); | |
2195 | |
2196 if (conf->upstream.busy_buffers_size == NGX_CONF_UNSET_SIZE) { | |
2197 conf->upstream.busy_buffers_size = 2 * size; | |
2198 | |
2199 } else if (conf->upstream.busy_buffers_size < size) { | |
2200 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2201 "\"fastcgi_busy_buffers_size\" must be equal or bigger than " | |
2202 "maximum of the value of \"fastcgi_header_buffer_size\" and " | |
2203 "one of the \"fastcgi_buffers\""); | |
2204 | |
2205 return NGX_CONF_ERROR; | |
2206 | |
2207 } else if (conf->upstream.busy_buffers_size | |
2208 > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size) | |
2209 { | |
2210 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2211 "\"fastcgi_busy_buffers_size\" must be less than " | |
2212 "the size of all \"fastcgi_buffers\" minus one buffer"); | |
2213 | |
2214 return NGX_CONF_ERROR; | |
2215 } | |
2216 | |
2217 | |
2218 ngx_conf_merge_size_value(conf->upstream.temp_file_write_size, | |
2219 prev->upstream.temp_file_write_size, | |
2220 NGX_CONF_UNSET_SIZE); | |
2221 | |
2222 if (conf->upstream.temp_file_write_size == NGX_CONF_UNSET_SIZE) { | |
2223 conf->upstream.temp_file_write_size = 2 * size; | |
2224 | |
2225 } else if (conf->upstream.temp_file_write_size < size) { | |
2226 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2227 "\"fastcgi_temp_file_write_size\" must be equal or bigger than " | |
2228 "maximum of the value of \"fastcgi_header_buffer_size\" and " | |
2229 "one of the \"fastcgi_buffers\""); | |
2230 | |
2231 return NGX_CONF_ERROR; | |
2232 } | |
2233 | |
2234 | |
2235 ngx_conf_merge_size_value(conf->upstream.max_temp_file_size, | |
2236 prev->upstream.max_temp_file_size, | |
2237 NGX_CONF_UNSET_SIZE); | |
2238 | |
2239 if (conf->upstream.max_temp_file_size == NGX_CONF_UNSET_SIZE) { | |
2240 | |
2241 conf->upstream.max_temp_file_size = 1024 * 1024 * 1024; | |
2242 | |
2243 } else if (conf->upstream.max_temp_file_size != 0 | |
2244 && conf->upstream.max_temp_file_size < size) | |
2245 { | |
2246 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, | |
2247 "\"fastcgi_max_temp_file_size\" must be equal to zero to disable " | |
2248 "the temporary files usage or must be equal or bigger than " | |
2249 "maximum of the value of \"fastcgi_header_buffer_size\" and " | |
2250 "one of the \"fastcgi_buffers\""); | |
2251 | |
2252 return NGX_CONF_ERROR; | |
2253 } | |
2254 | |
2255 | |
2256 ngx_conf_merge_bitmask_value(conf->upstream.next_upstream, | |
2257 prev->upstream.next_upstream, | |
2258 (NGX_CONF_BITMASK_SET | |
2259 |NGX_HTTP_UPSTREAM_FT_ERROR | |
2260 |NGX_HTTP_UPSTREAM_FT_TIMEOUT)); | |
2261 | |
2262 ngx_conf_merge_path_value(conf->upstream.temp_path, | |
2263 prev->upstream.temp_path, | |
2264 NGX_HTTP_FASTCGI_TEMP_PATH, 1, 2, 0, | |
2265 ngx_garbage_collector_temp_handler, cf); | |
2266 | |
2267 | |
2268 ngx_conf_merge_bitmask_value(conf->params, prev->params, | |
2269 (NGX_CONF_BITMASK_SET | |
2270 |NGX_HTTP_FASTCGI_REMOTE_ADDR | |
2271 |NGX_HTTP_FASTCGI_REMOTE_USER | |
2272 |NGX_HTTP_FASTCGI_SERVER_NAME | |
2273 |NGX_HTTP_FASTCGI_SERVER_PORT | |
2274 |NGX_HTTP_FASTCGI_SCRIPT_NAME | |
2275 |NGX_HTTP_FASTCGI_AUTH_TYPE | |
2276 |NGX_HTTP_FASTCGI_REQUEST_URI | |
2277 |NGX_HTTP_FASTCGI_REDIRECT_STATUS)); | |
2278 | |
2279 ngx_conf_merge_str_value(conf->root, prev->root, ""); | |
2280 | |
2281 if (conf->root.len && conf->root.data[conf->root.len - 1] == '/') { | |
2282 conf->root.len--; | |
2283 } | |
2284 | |
2285 ngx_conf_merge_str_value(conf->index, prev->index, ""); | |
2286 | |
2287 if (conf->vars == NULL) { | |
2288 conf->vars = prev->vars; | |
2289 } | |
2290 | |
2291 return NGX_CONF_OK; | |
2292 } |