?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update and clean Tomato RAF files
[tomato.git] / release / src / router / nginx / src / http / ngx_http_upstream.c
blob45e2eb7b96127dee995063636c6afa23f6daebd6
1
2 /*
3 * Copyright (C) Igor Sysoev
4 * Copyright (C) Nginx, Inc.
5 */
6
7
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 #include <ngx_http.h>
11
12
13 #if (NGX_HTTP_CACHE)
14 static ngx_int_t ngx_http_upstream_cache(ngx_http_request_t *r,
15 ngx_http_upstream_t *u);
16 static ngx_int_t ngx_http_upstream_cache_send(ngx_http_request_t *r,
17 ngx_http_upstream_t *u);
18 static ngx_int_t ngx_http_upstream_cache_status(ngx_http_request_t *r,
19 ngx_http_variable_value_t *v, uintptr_t data);
20 #endif
21
22 static void ngx_http_upstream_init_request(ngx_http_request_t *r);
23 static void ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx);
24 static void ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r);
25 static void ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r);
26 static void ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
27 ngx_event_t *ev);
28 static void ngx_http_upstream_connect(ngx_http_request_t *r,
29 ngx_http_upstream_t *u);
30 static ngx_int_t ngx_http_upstream_reinit(ngx_http_request_t *r,
31 ngx_http_upstream_t *u);
32 static void ngx_http_upstream_send_request(ngx_http_request_t *r,
33 ngx_http_upstream_t *u);
34 static void ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
35 ngx_http_upstream_t *u);
36 static void ngx_http_upstream_process_header(ngx_http_request_t *r,
37 ngx_http_upstream_t *u);
38 static ngx_int_t ngx_http_upstream_test_next(ngx_http_request_t *r,
39 ngx_http_upstream_t *u);
40 static ngx_int_t ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
41 ngx_http_upstream_t *u);
42 static ngx_int_t ngx_http_upstream_test_connect(ngx_connection_t *c);
43 static ngx_int_t ngx_http_upstream_process_headers(ngx_http_request_t *r,
44 ngx_http_upstream_t *u);
45 static void ngx_http_upstream_process_body_in_memory(ngx_http_request_t *r,
46 ngx_http_upstream_t *u);
47 static void ngx_http_upstream_send_response(ngx_http_request_t *r,
48 ngx_http_upstream_t *u);
49 static void ngx_http_upstream_upgrade(ngx_http_request_t *r,
50 ngx_http_upstream_t *u);
51 static void ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r);
52 static void ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r);
53 static void ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
54 ngx_http_upstream_t *u);
55 static void ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
56 ngx_http_upstream_t *u);
57 static void ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
58 ngx_uint_t from_upstream, ngx_uint_t do_write);
59 static void
60 ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r);
61 static void
62 ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
63 ngx_http_upstream_t *u);
64 static void
65 ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
66 ngx_uint_t do_write);
67 static ngx_int_t ngx_http_upstream_non_buffered_filter_init(void *data);
68 static ngx_int_t ngx_http_upstream_non_buffered_filter(void *data,
69 ssize_t bytes);
70 static void ngx_http_upstream_process_downstream(ngx_http_request_t *r);
71 static void ngx_http_upstream_process_upstream(ngx_http_request_t *r,
72 ngx_http_upstream_t *u);
73 static void ngx_http_upstream_process_request(ngx_http_request_t *r);
74 static void ngx_http_upstream_store(ngx_http_request_t *r,
75 ngx_http_upstream_t *u);
76 static void ngx_http_upstream_dummy_handler(ngx_http_request_t *r,
77 ngx_http_upstream_t *u);
78 static void ngx_http_upstream_next(ngx_http_request_t *r,
79 ngx_http_upstream_t *u, ngx_uint_t ft_type);
80 static void ngx_http_upstream_cleanup(void *data);
81 static void ngx_http_upstream_finalize_request(ngx_http_request_t *r,
82 ngx_http_upstream_t *u, ngx_int_t rc);
83
84 static ngx_int_t ngx_http_upstream_process_header_line(ngx_http_request_t *r,
85 ngx_table_elt_t *h, ngx_uint_t offset);
86 static ngx_int_t ngx_http_upstream_process_content_length(ngx_http_request_t *r,
87 ngx_table_elt_t *h, ngx_uint_t offset);
88 static ngx_int_t ngx_http_upstream_process_set_cookie(ngx_http_request_t *r,
89 ngx_table_elt_t *h, ngx_uint_t offset);
90 static ngx_int_t
91 ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
92 ngx_table_elt_t *h, ngx_uint_t offset);
93 static ngx_int_t ngx_http_upstream_ignore_header_line(ngx_http_request_t *r,
94 ngx_table_elt_t *h, ngx_uint_t offset);
95 static ngx_int_t ngx_http_upstream_process_expires(ngx_http_request_t *r,
96 ngx_table_elt_t *h, ngx_uint_t offset);
97 static ngx_int_t ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
98 ngx_table_elt_t *h, ngx_uint_t offset);
99 static ngx_int_t ngx_http_upstream_process_limit_rate(ngx_http_request_t *r,
100 ngx_table_elt_t *h, ngx_uint_t offset);
101 static ngx_int_t ngx_http_upstream_process_buffering(ngx_http_request_t *r,
102 ngx_table_elt_t *h, ngx_uint_t offset);
103 static ngx_int_t ngx_http_upstream_process_charset(ngx_http_request_t *r,
104 ngx_table_elt_t *h, ngx_uint_t offset);
105 static ngx_int_t ngx_http_upstream_process_connection(ngx_http_request_t *r,
106 ngx_table_elt_t *h, ngx_uint_t offset);
107 static ngx_int_t
108 ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
109 ngx_table_elt_t *h, ngx_uint_t offset);
110 static ngx_int_t ngx_http_upstream_copy_header_line(ngx_http_request_t *r,
111 ngx_table_elt_t *h, ngx_uint_t offset);
112 static ngx_int_t
113 ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
114 ngx_table_elt_t *h, ngx_uint_t offset);
115 static ngx_int_t ngx_http_upstream_copy_content_type(ngx_http_request_t *r,
116 ngx_table_elt_t *h, ngx_uint_t offset);
117 static ngx_int_t ngx_http_upstream_copy_last_modified(ngx_http_request_t *r,
118 ngx_table_elt_t *h, ngx_uint_t offset);
119 static ngx_int_t ngx_http_upstream_rewrite_location(ngx_http_request_t *r,
120 ngx_table_elt_t *h, ngx_uint_t offset);
121 static ngx_int_t ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r,
122 ngx_table_elt_t *h, ngx_uint_t offset);
123 static ngx_int_t ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r,
124 ngx_table_elt_t *h, ngx_uint_t offset);
125 static ngx_int_t ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
126 ngx_table_elt_t *h, ngx_uint_t offset);
127
128 #if (NGX_HTTP_GZIP)
129 static ngx_int_t ngx_http_upstream_copy_content_encoding(ngx_http_request_t *r,
130 ngx_table_elt_t *h, ngx_uint_t offset);
131 #endif
132
133 static ngx_int_t ngx_http_upstream_add_variables(ngx_conf_t *cf);
134 static ngx_int_t ngx_http_upstream_addr_variable(ngx_http_request_t *r,
135 ngx_http_variable_value_t *v, uintptr_t data);
136 static ngx_int_t ngx_http_upstream_status_variable(ngx_http_request_t *r,
137 ngx_http_variable_value_t *v, uintptr_t data);
138 static ngx_int_t ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
139 ngx_http_variable_value_t *v, uintptr_t data);
140 static ngx_int_t ngx_http_upstream_response_length_variable(
141 ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
142
143 static char *ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy);
144 static char *ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd,
145 void *conf);
146
147 static ngx_addr_t *ngx_http_upstream_get_local(ngx_http_request_t *r,
148 ngx_http_upstream_local_t *local);
149
150 static void *ngx_http_upstream_create_main_conf(ngx_conf_t *cf);
151 static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf);
152
153 #if (NGX_HTTP_SSL)
154 static void ngx_http_upstream_ssl_init_connection(ngx_http_request_t *,
155 ngx_http_upstream_t *u, ngx_connection_t *c);
156 static void ngx_http_upstream_ssl_handshake(ngx_connection_t *c);
157 #endif
158
159
160 ngx_http_upstream_header_t ngx_http_upstream_headers_in[] = {
161
162 { ngx_string("Status"),
163 ngx_http_upstream_process_header_line,
164 offsetof(ngx_http_upstream_headers_in_t, status),
165 ngx_http_upstream_copy_header_line, 0, 0 },
166
167 { ngx_string("Content-Type"),
168 ngx_http_upstream_process_header_line,
169 offsetof(ngx_http_upstream_headers_in_t, content_type),
170 ngx_http_upstream_copy_content_type, 0, 1 },
171
172 { ngx_string("Content-Length"),
173 ngx_http_upstream_process_content_length,
174 offsetof(ngx_http_upstream_headers_in_t, content_length),
175 ngx_http_upstream_ignore_header_line, 0, 0 },
176
177 { ngx_string("Date"),
178 ngx_http_upstream_process_header_line,
179 offsetof(ngx_http_upstream_headers_in_t, date),
180 ngx_http_upstream_copy_header_line,
181 offsetof(ngx_http_headers_out_t, date), 0 },
182
183 { ngx_string("Last-Modified"),
184 ngx_http_upstream_process_header_line,
185 offsetof(ngx_http_upstream_headers_in_t, last_modified),
186 ngx_http_upstream_copy_last_modified, 0, 0 },
187
188 { ngx_string("ETag"),
189 ngx_http_upstream_process_header_line,
190 offsetof(ngx_http_upstream_headers_in_t, etag),
191 ngx_http_upstream_copy_header_line,
192 offsetof(ngx_http_headers_out_t, etag), 0 },
193
194 { ngx_string("Server"),
195 ngx_http_upstream_process_header_line,
196 offsetof(ngx_http_upstream_headers_in_t, server),
197 ngx_http_upstream_copy_header_line,
198 offsetof(ngx_http_headers_out_t, server), 0 },
199
200 { ngx_string("WWW-Authenticate"),
201 ngx_http_upstream_process_header_line,
202 offsetof(ngx_http_upstream_headers_in_t, www_authenticate),
203 ngx_http_upstream_copy_header_line, 0, 0 },
204
205 { ngx_string("Location"),
206 ngx_http_upstream_process_header_line,
207 offsetof(ngx_http_upstream_headers_in_t, location),
208 ngx_http_upstream_rewrite_location, 0, 0 },
209
210 { ngx_string("Refresh"),
211 ngx_http_upstream_ignore_header_line, 0,
212 ngx_http_upstream_rewrite_refresh, 0, 0 },
213
214 { ngx_string("Set-Cookie"),
215 ngx_http_upstream_process_set_cookie, 0,
216 ngx_http_upstream_rewrite_set_cookie, 0, 1 },
217
218 { ngx_string("Content-Disposition"),
219 ngx_http_upstream_ignore_header_line, 0,
220 ngx_http_upstream_copy_header_line, 0, 1 },
221
222 { ngx_string("Cache-Control"),
223 ngx_http_upstream_process_cache_control, 0,
224 ngx_http_upstream_copy_multi_header_lines,
225 offsetof(ngx_http_headers_out_t, cache_control), 1 },
226
227 { ngx_string("Expires"),
228 ngx_http_upstream_process_expires, 0,
229 ngx_http_upstream_copy_header_line,
230 offsetof(ngx_http_headers_out_t, expires), 1 },
231
232 { ngx_string("Accept-Ranges"),
233 ngx_http_upstream_process_header_line,
234 offsetof(ngx_http_upstream_headers_in_t, accept_ranges),
235 ngx_http_upstream_copy_allow_ranges,
236 offsetof(ngx_http_headers_out_t, accept_ranges), 1 },
237
238 { ngx_string("Connection"),
239 ngx_http_upstream_process_connection, 0,
240 ngx_http_upstream_ignore_header_line, 0, 0 },
241
242 { ngx_string("Keep-Alive"),
243 ngx_http_upstream_ignore_header_line, 0,
244 ngx_http_upstream_ignore_header_line, 0, 0 },
245
246 { ngx_string("X-Powered-By"),
247 ngx_http_upstream_ignore_header_line, 0,
248 ngx_http_upstream_copy_header_line, 0, 0 },
249
250 { ngx_string("X-Accel-Expires"),
251 ngx_http_upstream_process_accel_expires, 0,
252 ngx_http_upstream_copy_header_line, 0, 0 },
253
254 { ngx_string("X-Accel-Redirect"),
255 ngx_http_upstream_process_header_line,
256 offsetof(ngx_http_upstream_headers_in_t, x_accel_redirect),
257 ngx_http_upstream_copy_header_line, 0, 0 },
258
259 { ngx_string("X-Accel-Limit-Rate"),
260 ngx_http_upstream_process_limit_rate, 0,
261 ngx_http_upstream_copy_header_line, 0, 0 },
262
263 { ngx_string("X-Accel-Buffering"),
264 ngx_http_upstream_process_buffering, 0,
265 ngx_http_upstream_copy_header_line, 0, 0 },
266
267 { ngx_string("X-Accel-Charset"),
268 ngx_http_upstream_process_charset, 0,
269 ngx_http_upstream_copy_header_line, 0, 0 },
270
271 { ngx_string("Transfer-Encoding"),
272 ngx_http_upstream_process_transfer_encoding, 0,
273 ngx_http_upstream_ignore_header_line, 0, 0 },
274
275 #if (NGX_HTTP_GZIP)
276 { ngx_string("Content-Encoding"),
277 ngx_http_upstream_process_header_line,
278 offsetof(ngx_http_upstream_headers_in_t, content_encoding),
279 ngx_http_upstream_copy_content_encoding, 0, 0 },
280 #endif
281
282 { ngx_null_string, NULL, 0, NULL, 0, 0 }
283 };
284
285
286 static ngx_command_t ngx_http_upstream_commands[] = {
287
288 { ngx_string("upstream"),
289 NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
290 ngx_http_upstream,
291 0,
292 0,
293 NULL },
294
295 { ngx_string("server"),
296 NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
297 ngx_http_upstream_server,
298 NGX_HTTP_SRV_CONF_OFFSET,
299 0,
300 NULL },
301
302 ngx_null_command
303 };
304
305
306 static ngx_http_module_t ngx_http_upstream_module_ctx = {
307 ngx_http_upstream_add_variables, /* preconfiguration */
308 NULL, /* postconfiguration */
309
310 ngx_http_upstream_create_main_conf, /* create main configuration */
311 ngx_http_upstream_init_main_conf, /* init main configuration */
312
313 NULL, /* create server configuration */
314 NULL, /* merge server configuration */
315
316 NULL, /* create location configuration */
317 NULL /* merge location configuration */
318 };
319
320
321 ngx_module_t ngx_http_upstream_module = {
322 NGX_MODULE_V1,
323 &ngx_http_upstream_module_ctx, /* module context */
324 ngx_http_upstream_commands, /* module directives */
325 NGX_HTTP_MODULE, /* module type */
326 NULL, /* init master */
327 NULL, /* init module */
328 NULL, /* init process */
329 NULL, /* init thread */
330 NULL, /* exit thread */
331 NULL, /* exit process */
332 NULL, /* exit master */
333 NGX_MODULE_V1_PADDING
334 };
335
336
337 static ngx_http_variable_t ngx_http_upstream_vars[] = {
338
339 { ngx_string("upstream_addr"), NULL,
340 ngx_http_upstream_addr_variable, 0,
341 NGX_HTTP_VAR_NOCACHEABLE, 0 },
342
343 { ngx_string("upstream_status"), NULL,
344 ngx_http_upstream_status_variable, 0,
345 NGX_HTTP_VAR_NOCACHEABLE, 0 },
346
347 { ngx_string("upstream_response_time"), NULL,
348 ngx_http_upstream_response_time_variable, 0,
349 NGX_HTTP_VAR_NOCACHEABLE, 0 },
350
351 { ngx_string("upstream_response_length"), NULL,
352 ngx_http_upstream_response_length_variable, 0,
353 NGX_HTTP_VAR_NOCACHEABLE, 0 },
354
355 #if (NGX_HTTP_CACHE)
356
357 { ngx_string("upstream_cache_status"), NULL,
358 ngx_http_upstream_cache_status, 0,
359 NGX_HTTP_VAR_NOCACHEABLE, 0 },
360
361 #endif
362
363 { ngx_null_string, NULL, NULL, 0, 0, 0 }
364 };
365
366
367 static ngx_http_upstream_next_t ngx_http_upstream_next_errors[] = {
368 { 500, NGX_HTTP_UPSTREAM_FT_HTTP_500 },
369 { 502, NGX_HTTP_UPSTREAM_FT_HTTP_502 },
370 { 503, NGX_HTTP_UPSTREAM_FT_HTTP_503 },
371 { 504, NGX_HTTP_UPSTREAM_FT_HTTP_504 },
372 { 404, NGX_HTTP_UPSTREAM_FT_HTTP_404 },
373 { 0, 0 }
374 };
375
376
377 ngx_conf_bitmask_t ngx_http_upstream_cache_method_mask[] = {
378 { ngx_string("GET"), NGX_HTTP_GET},
379 { ngx_string("HEAD"), NGX_HTTP_HEAD },
380 { ngx_string("POST"), NGX_HTTP_POST },
381 { ngx_null_string, 0 }
382 };
383
384
385 ngx_conf_bitmask_t ngx_http_upstream_ignore_headers_masks[] = {
386 { ngx_string("X-Accel-Redirect"), NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT },
387 { ngx_string("X-Accel-Expires"), NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES },
388 { ngx_string("X-Accel-Limit-Rate"), NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE },
389 { ngx_string("X-Accel-Buffering"), NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING },
390 { ngx_string("X-Accel-Charset"), NGX_HTTP_UPSTREAM_IGN_XA_CHARSET },
391 { ngx_string("Expires"), NGX_HTTP_UPSTREAM_IGN_EXPIRES },
392 { ngx_string("Cache-Control"), NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL },
393 { ngx_string("Set-Cookie"), NGX_HTTP_UPSTREAM_IGN_SET_COOKIE },
394 { ngx_null_string, 0 }
395 };
396
397
398 ngx_int_t
399 ngx_http_upstream_create(ngx_http_request_t *r)
400 {
401 ngx_http_upstream_t *u;
402
403 u = r->upstream;
404
405 if (u && u->cleanup) {
406 r->main->count++;
407 ngx_http_upstream_cleanup(r);
408 }
409
410 u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
411 if (u == NULL) {
412 return NGX_ERROR;
413 }
414
415 r->upstream = u;
416
417 u->peer.log = r->connection->log;
418 u->peer.log_error = NGX_ERROR_ERR;
419 #if (NGX_THREADS)
420 u->peer.lock = &r->connection->lock;
421 #endif
422
423 #if (NGX_HTTP_CACHE)
424 r->cache = NULL;
425 #endif
426
427 u->headers_in.content_length_n = -1;
428
429 return NGX_OK;
430 }
431
432
433 void
434 ngx_http_upstream_init(ngx_http_request_t *r)
435 {
436 ngx_connection_t *c;
437
438 c = r->connection;
439
440 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
441 "http init upstream, client timer: %d", c->read->timer_set);
442
443 #if (NGX_HTTP_SPDY)
444 if (r->spdy_stream) {
445 ngx_http_upstream_init_request(r);
446 return;
447 }
448 #endif
449
450 if (c->read->timer_set) {
451 ngx_del_timer(c->read);
452 }
453
454 if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {
455
456 if (!c->write->active) {
457 if (ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT)
458 == NGX_ERROR)
459 {
460 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
461 return;
462 }
463 }
464 }
465
466 ngx_http_upstream_init_request(r);
467 }
468
469
470 static void
471 ngx_http_upstream_init_request(ngx_http_request_t *r)
472 {
473 ngx_str_t *host;
474 ngx_uint_t i;
475 ngx_resolver_ctx_t *ctx, temp;
476 ngx_http_cleanup_t *cln;
477 ngx_http_upstream_t *u;
478 ngx_http_core_loc_conf_t *clcf;
479 ngx_http_upstream_srv_conf_t *uscf, **uscfp;
480 ngx_http_upstream_main_conf_t *umcf;
481
482 if (r->aio) {
483 return;
484 }
485
486 u = r->upstream;
487
488 #if (NGX_HTTP_CACHE)
489
490 if (u->conf->cache) {
491 ngx_int_t rc;
492
493 rc = ngx_http_upstream_cache(r, u);
494
495 if (rc == NGX_BUSY) {
496 r->write_event_handler = ngx_http_upstream_init_request;
497 return;
498 }
499
500 r->write_event_handler = ngx_http_request_empty_handler;
501
502 if (rc == NGX_DONE) {
503 return;
504 }
505
506 if (rc != NGX_DECLINED) {
507 ngx_http_finalize_request(r, rc);
508 return;
509 }
510 }
511
512 #endif
513
514 u->store = (u->conf->store || u->conf->store_lengths);
515
516 if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
517 r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;
518 r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
519 }
520
521 if (r->request_body) {
522 u->request_bufs = r->request_body->bufs;
523 }
524
525 if (u->create_request(r) != NGX_OK) {
526 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
527 return;
528 }
529
530 u->peer.local = ngx_http_upstream_get_local(r, u->conf->local);
531
532 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
533
534 u->output.alignment = clcf->directio_alignment;
535 u->output.pool = r->pool;
536 u->output.bufs.num = 1;
537 u->output.bufs.size = clcf->client_body_buffer_size;
538 u->output.output_filter = ngx_chain_writer;
539 u->output.filter_ctx = &u->writer;
540
541 u->writer.pool = r->pool;
542
543 if (r->upstream_states == NULL) {
544
545 r->upstream_states = ngx_array_create(r->pool, 1,
546 sizeof(ngx_http_upstream_state_t));
547 if (r->upstream_states == NULL) {
548 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
549 return;
550 }
551
552 } else {
553
554 u->state = ngx_array_push(r->upstream_states);
555 if (u->state == NULL) {
556 ngx_http_upstream_finalize_request(r, u,
557 NGX_HTTP_INTERNAL_SERVER_ERROR);
558 return;
559 }
560
561 ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
562 }
563
564 cln = ngx_http_cleanup_add(r, 0);
565 if (cln == NULL) {
566 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
567 return;
568 }
569
570 cln->handler = ngx_http_upstream_cleanup;
571 cln->data = r;
572 u->cleanup = &cln->handler;
573
574 if (u->resolved == NULL) {
575
576 uscf = u->conf->upstream;
577
578 } else {
579
580 if (u->resolved->sockaddr) {
581
582 if (ngx_http_upstream_create_round_robin_peer(r, u->resolved)
583 != NGX_OK)
584 {
585 ngx_http_upstream_finalize_request(r, u,
586 NGX_HTTP_INTERNAL_SERVER_ERROR);
587 return;
588 }
589
590 ngx_http_upstream_connect(r, u);
591
592 return;
593 }
594
595 host = &u->resolved->host;
596
597 umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
598
599 uscfp = umcf->upstreams.elts;
600
601 for (i = 0; i < umcf->upstreams.nelts; i++) {
602
603 uscf = uscfp[i];
604
605 if (uscf->host.len == host->len
606 && ((uscf->port == 0 && u->resolved->no_port)
607 || uscf->port == u->resolved->port)
608 && ngx_memcmp(uscf->host.data, host->data, host->len) == 0)
609 {
610 goto found;
611 }
612 }
613
614 if (u->resolved->port == 0) {
615 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
616 "no port in upstream \"%V\"", host);
617 ngx_http_upstream_finalize_request(r, u,
618 NGX_HTTP_INTERNAL_SERVER_ERROR);
619 return;
620 }
621
622 temp.name = *host;
623
624 ctx = ngx_resolve_start(clcf->resolver, &temp);
625 if (ctx == NULL) {
626 ngx_http_upstream_finalize_request(r, u,
627 NGX_HTTP_INTERNAL_SERVER_ERROR);
628 return;
629 }
630
631 if (ctx == NGX_NO_RESOLVER) {
632 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
633 "no resolver defined to resolve %V", host);
634
635 ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
636 return;
637 }
638
639 ctx->name = *host;
640 ctx->type = NGX_RESOLVE_A;
641 ctx->handler = ngx_http_upstream_resolve_handler;
642 ctx->data = r;
643 ctx->timeout = clcf->resolver_timeout;
644
645 u->resolved->ctx = ctx;
646
647 if (ngx_resolve_name(ctx) != NGX_OK) {
648 u->resolved->ctx = NULL;
649 ngx_http_upstream_finalize_request(r, u,
650 NGX_HTTP_INTERNAL_SERVER_ERROR);
651 return;
652 }
653
654 return;
655 }
656
657 found:
658
659 if (uscf == NULL) {
660 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
661 "no upstream configuration");
662 ngx_http_upstream_finalize_request(r, u,
663 NGX_HTTP_INTERNAL_SERVER_ERROR);
664 return;
665 }
666
667 if (uscf->peer.init(r, uscf) != NGX_OK) {
668 ngx_http_upstream_finalize_request(r, u,
669 NGX_HTTP_INTERNAL_SERVER_ERROR);
670 return;
671 }
672
673 ngx_http_upstream_connect(r, u);
674 }
675
676
677 #if (NGX_HTTP_CACHE)
678
679 static ngx_int_t
680 ngx_http_upstream_cache(ngx_http_request_t *r, ngx_http_upstream_t *u)
681 {
682 ngx_int_t rc;
683 ngx_http_cache_t *c;
684
685 c = r->cache;
686
687 if (c == NULL) {
688
689 if (!(r->method & u->conf->cache_methods)) {
690 return NGX_DECLINED;
691 }
692
693 if (r->method & NGX_HTTP_HEAD) {
694 u->method = ngx_http_core_get_method;
695 }
696
697 if (ngx_http_file_cache_new(r) != NGX_OK) {
698 return NGX_ERROR;
699 }
700
701 if (u->create_key(r) != NGX_OK) {
702 return NGX_ERROR;
703 }
704
705 /* TODO: add keys */
706
707 ngx_http_file_cache_create_key(r);
708
709 if (r->cache->header_start + 256 >= u->conf->buffer_size) {
710 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
711 "%V_buffer_size %uz is not enough for cache key, "
712 "it should increased at least to %uz",
713 &u->conf->module, u->conf->buffer_size,
714 ngx_align(r->cache->header_start + 256, 1024));
715
716 r->cache = NULL;
717 return NGX_DECLINED;
718 }
719
720 u->cacheable = 1;
721
722 switch (ngx_http_test_predicates(r, u->conf->cache_bypass)) {
723
724 case NGX_ERROR:
725 return NGX_ERROR;
726
727 case NGX_DECLINED:
728 u->cache_status = NGX_HTTP_CACHE_BYPASS;
729 return NGX_DECLINED;
730
731 default: /* NGX_OK */
732 break;
733 }
734
735 c = r->cache;
736
737 c->min_uses = u->conf->cache_min_uses;
738 c->body_start = u->conf->buffer_size;
739 c->file_cache = u->conf->cache->data;
740
741 c->lock = u->conf->cache_lock;
742 c->lock_timeout = u->conf->cache_lock_timeout;
743
744 u->cache_status = NGX_HTTP_CACHE_MISS;
745 }
746
747 rc = ngx_http_file_cache_open(r);
748
749 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
750 "http upstream cache: %i", rc);
751
752 switch (rc) {
753
754 case NGX_HTTP_CACHE_UPDATING:
755
756 if (u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING) {
757 u->cache_status = rc;
758 rc = NGX_OK;
759
760 } else {
761 rc = NGX_HTTP_CACHE_STALE;
762 }
763
764 break;
765
766 case NGX_OK:
767 u->cache_status = NGX_HTTP_CACHE_HIT;
768 }
769
770 switch (rc) {
771
772 case NGX_OK:
773
774 rc = ngx_http_upstream_cache_send(r, u);
775
776 if (rc != NGX_HTTP_UPSTREAM_INVALID_HEADER) {
777 return rc;
778 }
779
780 break;
781
782 case NGX_HTTP_CACHE_STALE:
783
784 c->valid_sec = 0;
785 u->buffer.start = NULL;
786 u->cache_status = NGX_HTTP_CACHE_EXPIRED;
787
788 break;
789
790 case NGX_DECLINED:
791
792 if ((size_t) (u->buffer.end - u->buffer.start) < u->conf->buffer_size) {
793 u->buffer.start = NULL;
794
795 } else {
796 u->buffer.pos = u->buffer.start + c->header_start;
797 u->buffer.last = u->buffer.pos;
798 }
799
800 break;
801
802 case NGX_HTTP_CACHE_SCARCE:
803
804 u->cacheable = 0;
805
806 break;
807
808 case NGX_AGAIN:
809
810 return NGX_BUSY;
811
812 case NGX_ERROR:
813
814 return NGX_ERROR;
815
816 default:
817
818 /* cached NGX_HTTP_BAD_GATEWAY, NGX_HTTP_GATEWAY_TIME_OUT, etc. */
819
820 u->cache_status = NGX_HTTP_CACHE_HIT;
821
822 return rc;
823 }
824
825 r->cached = 0;
826
827 return NGX_DECLINED;
828 }
829
830
831 static ngx_int_t
832 ngx_http_upstream_cache_send(ngx_http_request_t *r, ngx_http_upstream_t *u)
833 {
834 ngx_int_t rc;
835 ngx_http_cache_t *c;
836
837 r->cached = 1;
838 c = r->cache;
839
840 if (c->header_start == c->body_start) {
841 r->http_version = NGX_HTTP_VERSION_9;
842 return ngx_http_cache_send(r);
843 }
844
845 /* TODO: cache stack */
846
847 u->buffer = *c->buf;
848 u->buffer.pos += c->header_start;
849
850 ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
851 u->headers_in.content_length_n = -1;
852
853 if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
854 sizeof(ngx_table_elt_t))
855 != NGX_OK)
856 {
857 return NGX_ERROR;
858 }
859
860 rc = u->process_header(r);
861
862 if (rc == NGX_OK) {
863
864 if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
865 return NGX_DONE;
866 }
867
868 return ngx_http_cache_send(r);
869 }
870
871 if (rc == NGX_ERROR) {
872 return NGX_ERROR;
873 }
874
875 /* rc == NGX_HTTP_UPSTREAM_INVALID_HEADER */
876
877 /* TODO: delete file */
878
879 return rc;
880 }
881
882 #endif
883
884
885 static void
886 ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
887 {
888 ngx_connection_t *c;
889 ngx_http_request_t *r;
890 ngx_http_upstream_t *u;
891 ngx_http_upstream_resolved_t *ur;
892
893 r = ctx->data;
894 c = r->connection;
895
896 u = r->upstream;
897 ur = u->resolved;
898
899 if (ctx->state) {
900 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
901 "%V could not be resolved (%i: %s)",
902 &ctx->name, ctx->state,
903 ngx_resolver_strerror(ctx->state));
904
905 ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
906 goto failed;
907 }
908
909 ur->naddrs = ctx->naddrs;
910 ur->addrs = ctx->addrs;
911
912 #if (NGX_DEBUG)
913 {
914 in_addr_t addr;
915 ngx_uint_t i;
916
917 for (i = 0; i < ctx->naddrs; i++) {
918 addr = ntohl(ur->addrs[i]);
919
920 ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
921 "name was resolved to %ud.%ud.%ud.%ud",
922 (addr >> 24) & 0xff, (addr >> 16) & 0xff,
923 (addr >> 8) & 0xff, addr & 0xff);
924 }
925 }
926 #endif
927
928 if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
929 ngx_http_upstream_finalize_request(r, u,
930 NGX_HTTP_INTERNAL_SERVER_ERROR);
931 goto failed;
932 }
933
934 ngx_resolve_name_done(ctx);
935 ur->ctx = NULL;
936
937 ngx_http_upstream_connect(r, u);
938
939 failed:
940
941 ngx_http_run_posted_requests(c);
942 }
943
944
945 static void
946 ngx_http_upstream_handler(ngx_event_t *ev)
947 {
948 ngx_connection_t *c;
949 ngx_http_request_t *r;
950 ngx_http_log_ctx_t *ctx;
951 ngx_http_upstream_t *u;
952
953 c = ev->data;
954 r = c->data;
955
956 u = r->upstream;
957 c = r->connection;
958
959 ctx = c->log->data;
960 ctx->current_request = r;
961
962 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
963 "http upstream request: \"%V?%V\"", &r->uri, &r->args);
964
965 if (ev->write) {
966 u->write_event_handler(r, u);
967
968 } else {
969 u->read_event_handler(r, u);
970 }
971
972 ngx_http_run_posted_requests(c);
973 }
974
975
976 static void
977 ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r)
978 {
979 ngx_http_upstream_check_broken_connection(r, r->connection->read);
980 }
981
982
983 static void
984 ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r)
985 {
986 ngx_http_upstream_check_broken_connection(r, r->connection->write);
987 }
988
989
990 static void
991 ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
992 ngx_event_t *ev)
993 {
994 int n;
995 char buf[1];
996 ngx_err_t err;
997 ngx_int_t event;
998 ngx_connection_t *c;
999 ngx_http_upstream_t *u;
1000
1001 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, ev->log, 0,
1002 "http upstream check client, write event:%d, \"%V\"",
1003 ev->write, &r->uri);
1004
1005 c = r->connection;
1006 u = r->upstream;
1007
1008 if (c->error) {
1009 if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {
1010
1011 event = ev->write ? NGX_WRITE_EVENT : NGX_READ_EVENT;
1012
1013 if (ngx_del_event(ev, event, 0) != NGX_OK) {
1014 ngx_http_upstream_finalize_request(r, u,
1015 NGX_HTTP_INTERNAL_SERVER_ERROR);
1016 return;
1017 }
1018 }
1019
1020 if (!u->cacheable) {
1021 ngx_http_upstream_finalize_request(r, u,
1022 NGX_HTTP_CLIENT_CLOSED_REQUEST);
1023 }
1024
1025 return;
1026 }
1027
1028 #if (NGX_HTTP_SPDY)
1029 if (r->spdy_stream) {
1030 return;
1031 }
1032 #endif
1033
1034 #if (NGX_HAVE_KQUEUE)
1035
1036 if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
1037
1038 if (!ev->pending_eof) {
1039 return;
1040 }
1041
1042 ev->eof = 1;
1043 c->error = 1;
1044
1045 if (ev->kq_errno) {
1046 ev->error = 1;
1047 }
1048
1049 if (!u->cacheable && u->peer.connection) {
1050 ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
1051 "kevent() reported that client prematurely closed "
1052 "connection, so upstream connection is closed too");
1053 ngx_http_upstream_finalize_request(r, u,
1054 NGX_HTTP_CLIENT_CLOSED_REQUEST);
1055 return;
1056 }
1057
1058 ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
1059 "kevent() reported that client prematurely closed "
1060 "connection");
1061
1062 if (u->peer.connection == NULL) {
1063 ngx_http_upstream_finalize_request(r, u,
1064 NGX_HTTP_CLIENT_CLOSED_REQUEST);
1065 }
1066
1067 return;
1068 }
1069
1070 #endif
1071
1072 n = recv(c->fd, buf, 1, MSG_PEEK);
1073
1074 err = ngx_socket_errno;
1075
1076 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ev->log, err,
1077 "http upstream recv(): %d", n);
1078
1079 if (ev->write && (n >= 0 || err == NGX_EAGAIN)) {
1080 return;
1081 }
1082
1083 if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {
1084
1085 event = ev->write ? NGX_WRITE_EVENT : NGX_READ_EVENT;
1086
1087 if (ngx_del_event(ev, event, 0) != NGX_OK) {
1088 ngx_http_upstream_finalize_request(r, u,
1089 NGX_HTTP_INTERNAL_SERVER_ERROR);
1090 return;
1091 }
1092 }
1093
1094 if (n > 0) {
1095 return;
1096 }
1097
1098 if (n == -1) {
1099 if (err == NGX_EAGAIN) {
1100 return;
1101 }
1102
1103 ev->error = 1;
1104
1105 } else { /* n == 0 */
1106 err = 0;
1107 }
1108
1109 ev->eof = 1;
1110 c->error = 1;
1111
1112 if (!u->cacheable && u->peer.connection) {
1113 ngx_log_error(NGX_LOG_INFO, ev->log, err,
1114 "client prematurely closed connection, "
1115 "so upstream connection is closed too");
1116 ngx_http_upstream_finalize_request(r, u,
1117 NGX_HTTP_CLIENT_CLOSED_REQUEST);
1118 return;
1119 }
1120
1121 ngx_log_error(NGX_LOG_INFO, ev->log, err,
1122 "client prematurely closed connection");
1123
1124 if (u->peer.connection == NULL) {
1125 ngx_http_upstream_finalize_request(r, u,
1126 NGX_HTTP_CLIENT_CLOSED_REQUEST);
1127 }
1128 }
1129
1130
1131 static void
1132 ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
1133 {
1134 ngx_int_t rc;
1135 ngx_time_t *tp;
1136 ngx_connection_t *c;
1137
1138 r->connection->log->action = "connecting to upstream";
1139
1140 if (u->state && u->state->response_sec) {
1141 tp = ngx_timeofday();
1142 u->state->response_sec = tp->sec - u->state->response_sec;
1143 u->state->response_msec = tp->msec - u->state->response_msec;
1144 }
1145
1146 u->state = ngx_array_push(r->upstream_states);
1147 if (u->state == NULL) {
1148 ngx_http_upstream_finalize_request(r, u,
1149 NGX_HTTP_INTERNAL_SERVER_ERROR);
1150 return;
1151 }
1152
1153 ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
1154
1155 tp = ngx_timeofday();
1156 u->state->response_sec = tp->sec;
1157 u->state->response_msec = tp->msec;
1158
1159 rc = ngx_event_connect_peer(&u->peer);
1160
1161 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
1162 "http upstream connect: %i", rc);
1163
1164 if (rc == NGX_ERROR) {
1165 ngx_http_upstream_finalize_request(r, u,
1166 NGX_HTTP_INTERNAL_SERVER_ERROR);
1167 return;
1168 }
1169
1170 u->state->peer = u->peer.name;
1171
1172 if (rc == NGX_BUSY) {
1173 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
1174 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);
1175 return;
1176 }
1177
1178 if (rc == NGX_DECLINED) {
1179 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
1180 return;
1181 }
1182
1183 /* rc == NGX_OK || rc == NGX_AGAIN */
1184
1185 c = u->peer.connection;
1186
1187 c->data = r;
1188
1189 c->write->handler = ngx_http_upstream_handler;
1190 c->read->handler = ngx_http_upstream_handler;
1191
1192 u->write_event_handler = ngx_http_upstream_send_request_handler;
1193 u->read_event_handler = ngx_http_upstream_process_header;
1194
1195 c->sendfile &= r->connection->sendfile;
1196 u->output.sendfile = c->sendfile;
1197
1198 if (c->pool == NULL) {
1199
1200 /* we need separate pool here to be able to cache SSL connections */
1201
1202 c->pool = ngx_create_pool(128, r->connection->log);
1203 if (c->pool == NULL) {
1204 ngx_http_upstream_finalize_request(r, u,
1205 NGX_HTTP_INTERNAL_SERVER_ERROR);
1206 return;
1207 }
1208 }
1209
1210 c->log = r->connection->log;
1211 c->pool->log = c->log;
1212 c->read->log = c->log;
1213 c->write->log = c->log;
1214
1215 /* init or reinit the ngx_output_chain() and ngx_chain_writer() contexts */
1216
1217 u->writer.out = NULL;
1218 u->writer.last = &u->writer.out;
1219 u->writer.connection = c;
1220 u->writer.limit = 0;
1221
1222 if (u->request_sent) {
1223 if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
1224 ngx_http_upstream_finalize_request(r, u,
1225 NGX_HTTP_INTERNAL_SERVER_ERROR);
1226 return;
1227 }
1228 }
1229
1230 if (r->request_body
1231 && r->request_body->buf
1232 && r->request_body->temp_file
1233 && r == r->main)
1234 {
1235 /*
1236 * the r->request_body->buf can be reused for one request only,
1237 * the subrequests should allocate their own temporary bufs
1238 */
1239
1240 u->output.free = ngx_alloc_chain_link(r->pool);
1241 if (u->output.free == NULL) {
1242 ngx_http_upstream_finalize_request(r, u,
1243 NGX_HTTP_INTERNAL_SERVER_ERROR);
1244 return;
1245 }
1246
1247 u->output.free->buf = r->request_body->buf;
1248 u->output.free->next = NULL;
1249 u->output.allocated = 1;
1250
1251 r->request_body->buf->pos = r->request_body->buf->start;
1252 r->request_body->buf->last = r->request_body->buf->start;
1253 r->request_body->buf->tag = u->output.tag;
1254 }
1255
1256 u->request_sent = 0;
1257
1258 if (rc == NGX_AGAIN) {
1259 ngx_add_timer(c->write, u->conf->connect_timeout);
1260 return;
1261 }
1262
1263 #if (NGX_HTTP_SSL)
1264
1265 if (u->ssl && c->ssl == NULL) {
1266 ngx_http_upstream_ssl_init_connection(r, u, c);
1267 return;
1268 }
1269
1270 #endif
1271
1272 ngx_http_upstream_send_request(r, u);
1273 }
1274
1275
1276 #if (NGX_HTTP_SSL)
1277
1278 static void
1279 ngx_http_upstream_ssl_init_connection(ngx_http_request_t *r,
1280 ngx_http_upstream_t *u, ngx_connection_t *c)
1281 {
1282 ngx_int_t rc;
1283
1284 if (ngx_ssl_create_connection(u->conf->ssl, c,
1285 NGX_SSL_BUFFER|NGX_SSL_CLIENT)
1286 != NGX_OK)
1287 {
1288 ngx_http_upstream_finalize_request(r, u,
1289 NGX_HTTP_INTERNAL_SERVER_ERROR);
1290 return;
1291 }
1292
1293 c->sendfile = 0;
1294 u->output.sendfile = 0;
1295
1296 if (u->conf->ssl_session_reuse) {
1297 if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
1298 ngx_http_upstream_finalize_request(r, u,
1299 NGX_HTTP_INTERNAL_SERVER_ERROR);
1300 return;
1301 }
1302 }
1303
1304 r->connection->log->action = "SSL handshaking to upstream";
1305
1306 rc = ngx_ssl_handshake(c);
1307
1308 if (rc == NGX_AGAIN) {
1309 c->ssl->handler = ngx_http_upstream_ssl_handshake;
1310 return;
1311 }
1312
1313 ngx_http_upstream_ssl_handshake(c);
1314 }
1315
1316
1317 static void
1318 ngx_http_upstream_ssl_handshake(ngx_connection_t *c)
1319 {
1320 ngx_http_request_t *r;
1321 ngx_http_upstream_t *u;
1322
1323 r = c->data;
1324 u = r->upstream;
1325
1326 if (c->ssl->handshaked) {
1327
1328 if (u->conf->ssl_session_reuse) {
1329 u->peer.save_session(&u->peer, u->peer.data);
1330 }
1331
1332 c->write->handler = ngx_http_upstream_handler;
1333 c->read->handler = ngx_http_upstream_handler;
1334
1335 ngx_http_upstream_send_request(r, u);
1336
1337 return;
1338 }
1339
1340 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
1341
1342 }
1343
1344 #endif
1345
1346
1347 static ngx_int_t
1348 ngx_http_upstream_reinit(ngx_http_request_t *r, ngx_http_upstream_t *u)
1349 {
1350 ngx_chain_t *cl;
1351
1352 if (u->reinit_request(r) != NGX_OK) {
1353 return NGX_ERROR;
1354 }
1355
1356 u->keepalive = 0;
1357 u->upgrade = 0;
1358
1359 ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
1360 u->headers_in.content_length_n = -1;
1361
1362 if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
1363 sizeof(ngx_table_elt_t))
1364 != NGX_OK)
1365 {
1366 return NGX_ERROR;
1367 }
1368
1369 /* reinit the request chain */
1370
1371 for (cl = u->request_bufs; cl; cl = cl->next) {
1372 cl->buf->pos = cl->buf->start;
1373 cl->buf->file_pos = 0;
1374 }
1375
1376 /* reinit the subrequest's ngx_output_chain() context */
1377
1378 if (r->request_body && r->request_body->temp_file
1379 && r != r->main && u->output.buf)
1380 {
1381 u->output.free = ngx_alloc_chain_link(r->pool);
1382 if (u->output.free == NULL) {
1383 return NGX_ERROR;
1384 }
1385
1386 u->output.free->buf = u->output.buf;
1387 u->output.free->next = NULL;
1388
1389 u->output.buf->pos = u->output.buf->start;
1390 u->output.buf->last = u->output.buf->start;
1391 }
1392
1393 u->output.buf = NULL;
1394 u->output.in = NULL;
1395 u->output.busy = NULL;
1396
1397 /* reinit u->buffer */
1398
1399 u->buffer.pos = u->buffer.start;
1400
1401 #if (NGX_HTTP_CACHE)
1402
1403 if (r->cache) {
1404 u->buffer.pos += r->cache->header_start;
1405 }
1406
1407 #endif
1408
1409 u->buffer.last = u->buffer.pos;
1410
1411 return NGX_OK;
1412 }
1413
1414
1415 static void
1416 ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u)
1417 {
1418 ngx_int_t rc;
1419 ngx_connection_t *c;
1420
1421 c = u->peer.connection;
1422
1423 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
1424 "http upstream send request");
1425
1426 if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
1427 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
1428 return;
1429 }
1430
1431 c->log->action = "sending request to upstream";
1432
1433 rc = ngx_output_chain(&u->output, u->request_sent ? NULL : u->request_bufs);
1434
1435 u->request_sent = 1;
1436
1437 if (rc == NGX_ERROR) {
1438 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
1439 return;
1440 }
1441
1442 if (c->write->timer_set) {
1443 ngx_del_timer(c->write);
1444 }
1445
1446 if (rc == NGX_AGAIN) {
1447 ngx_add_timer(c->write, u->conf->send_timeout);
1448
1449 if (ngx_handle_write_event(c->write, u->conf->send_lowat) != NGX_OK) {
1450 ngx_http_upstream_finalize_request(r, u,
1451 NGX_HTTP_INTERNAL_SERVER_ERROR);
1452 return;
1453 }
1454
1455 return;
1456 }
1457
1458 /* rc == NGX_OK */
1459
1460 if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
1461 if (ngx_tcp_push(c->fd) == NGX_ERROR) {
1462 ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
1463 ngx_tcp_push_n " failed");
1464 ngx_http_upstream_finalize_request(r, u,
1465 NGX_HTTP_INTERNAL_SERVER_ERROR);
1466 return;
1467 }
1468
1469 c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
1470 }
1471
1472 ngx_add_timer(c->read, u->conf->read_timeout);
1473
1474 #if 1
1475 if (c->read->ready) {
1476
1477 /* post aio operation */
1478
1479 /*
1480 * TODO comment
1481 * although we can post aio operation just in the end
1482 * of ngx_http_upstream_connect() CHECK IT !!!
1483 * it's better to do here because we postpone header buffer allocation
1484 */
1485
1486 ngx_http_upstream_process_header(r, u);
1487 return;
1488 }
1489 #endif
1490
1491 u->write_event_handler = ngx_http_upstream_dummy_handler;
1492
1493 if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
1494 ngx_http_upstream_finalize_request(r, u,
1495 NGX_HTTP_INTERNAL_SERVER_ERROR);
1496 return;
1497 }
1498 }
1499
1500
1501 static void
1502 ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
1503 ngx_http_upstream_t *u)
1504 {
1505 ngx_connection_t *c;
1506
1507 c = u->peer.connection;
1508
1509 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
1510 "http upstream send request handler");
1511
1512 if (c->write->timedout) {
1513 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
1514 return;
1515 }
1516
1517 #if (NGX_HTTP_SSL)
1518
1519 if (u->ssl && c->ssl == NULL) {
1520 ngx_http_upstream_ssl_init_connection(r, u, c);
1521 return;
1522 }
1523
1524 #endif
1525
1526 if (u->header_sent) {
1527 u->write_event_handler = ngx_http_upstream_dummy_handler;
1528
1529 (void) ngx_handle_write_event(c->write, 0);
1530
1531 return;
1532 }
1533
1534 ngx_http_upstream_send_request(r, u);
1535 }
1536
1537
1538 static void
1539 ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u)
1540 {
1541 ssize_t n;
1542 ngx_int_t rc;
1543 ngx_connection_t *c;
1544
1545 c = u->peer.connection;
1546
1547 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
1548 "http upstream process header");
1549
1550 c->log->action = "reading response header from upstream";
1551
1552 if (c->read->timedout) {
1553 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
1554 return;
1555 }
1556
1557 if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
1558 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
1559 return;
1560 }
1561
1562 if (u->buffer.start == NULL) {
1563 u->buffer.start = ngx_palloc(r->pool, u->conf->buffer_size);
1564 if (u->buffer.start == NULL) {
1565 ngx_http_upstream_finalize_request(r, u,
1566 NGX_HTTP_INTERNAL_SERVER_ERROR);
1567 return;
1568 }
1569
1570 u->buffer.pos = u->buffer.start;
1571 u->buffer.last = u->buffer.start;
1572 u->buffer.end = u->buffer.start + u->conf->buffer_size;
1573 u->buffer.temporary = 1;
1574
1575 u->buffer.tag = u->output.tag;
1576
1577 if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
1578 sizeof(ngx_table_elt_t))
1579 != NGX_OK)
1580 {
1581 ngx_http_upstream_finalize_request(r, u,
1582 NGX_HTTP_INTERNAL_SERVER_ERROR);
1583 return;
1584 }
1585
1586 #if (NGX_HTTP_CACHE)
1587
1588 if (r->cache) {
1589 u->buffer.pos += r->cache->header_start;
1590 u->buffer.last = u->buffer.pos;
1591 }
1592 #endif
1593 }
1594
1595 for ( ;; ) {
1596
1597 n = c->recv(c, u->buffer.last, u->buffer.end - u->buffer.last);
1598
1599 if (n == NGX_AGAIN) {
1600 #if 0
1601 ngx_add_timer(rev, u->read_timeout);
1602 #endif
1603
1604 if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
1605 ngx_http_upstream_finalize_request(r, u,
1606 NGX_HTTP_INTERNAL_SERVER_ERROR);
1607 return;
1608 }
1609
1610 return;
1611 }
1612
1613 if (n == 0) {
1614 ngx_log_error(NGX_LOG_ERR, c->log, 0,
1615 "upstream prematurely closed connection");
1616 }
1617
1618 if (n == NGX_ERROR || n == 0) {
1619 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
1620 return;
1621 }
1622
1623 u->buffer.last += n;
1624
1625 #if 0
1626 u->valid_header_in = 0;
1627
1628 u->peer.cached = 0;
1629 #endif
1630
1631 rc = u->process_header(r);
1632
1633 if (rc == NGX_AGAIN) {
1634
1635 if (u->buffer.last == u->buffer.end) {
1636 ngx_log_error(NGX_LOG_ERR, c->log, 0,
1637 "upstream sent too big header");
1638
1639 ngx_http_upstream_next(r, u,
1640 NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
1641 return;
1642 }
1643
1644 continue;
1645 }
1646
1647 break;
1648 }
1649
1650 if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
1651 ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
1652 return;
1653 }
1654
1655 if (rc == NGX_ERROR) {
1656 ngx_http_upstream_finalize_request(r, u,
1657 NGX_HTTP_INTERNAL_SERVER_ERROR);
1658 return;
1659 }
1660
1661 /* rc == NGX_OK */
1662
1663 if (u->headers_in.status_n > NGX_HTTP_SPECIAL_RESPONSE) {
1664
1665 if (r->subrequest_in_memory) {
1666 u->buffer.last = u->buffer.pos;
1667 }
1668
1669 if (ngx_http_upstream_test_next(r, u) == NGX_OK) {
1670 return;
1671 }
1672
1673 if (ngx_http_upstream_intercept_errors(r, u) == NGX_OK) {
1674 return;
1675 }
1676 }
1677
1678 if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
1679 return;
1680 }
1681
1682 if (!r->subrequest_in_memory) {
1683 ngx_http_upstream_send_response(r, u);
1684 return;
1685 }
1686
1687 /* subrequest content in memory */
1688
1689 if (u->input_filter == NULL) {
1690 u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
1691 u->input_filter = ngx_http_upstream_non_buffered_filter;
1692 u->input_filter_ctx = r;
1693 }
1694
1695 if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
1696 ngx_http_upstream_finalize_request(r, u,
1697 NGX_HTTP_INTERNAL_SERVER_ERROR);
1698 return;
1699 }
1700
1701 n = u->buffer.last - u->buffer.pos;
1702
1703 if (n) {
1704 u->buffer.last -= n;
1705
1706 u->state->response_length += n;
1707
1708 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
1709 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
1710 return;
1711 }
1712
1713 if (u->length == 0) {
1714 ngx_http_upstream_finalize_request(r, u, 0);
1715 return;
1716 }
1717 }
1718
1719 u->read_event_handler = ngx_http_upstream_process_body_in_memory;
1720
1721 ngx_http_upstream_process_body_in_memory(r, u);
1722 }
1723
1724
1725 static ngx_int_t
1726 ngx_http_upstream_test_next(ngx_http_request_t *r, ngx_http_upstream_t *u)
1727 {
1728 ngx_uint_t status;
1729 ngx_http_upstream_next_t *un;
1730
1731 status = u->headers_in.status_n;
1732
1733 for (un = ngx_http_upstream_next_errors; un->status; un++) {
1734
1735 if (status != un->status) {
1736 continue;
1737 }
1738
1739 if (u->peer.tries > 1 && (u->conf->next_upstream & un->mask)) {
1740 ngx_http_upstream_next(r, u, un->mask);
1741 return NGX_OK;
1742 }
1743
1744 #if (NGX_HTTP_CACHE)
1745
1746 if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
1747 && (u->conf->cache_use_stale & un->mask))
1748 {
1749 ngx_int_t rc;
1750
1751 rc = u->reinit_request(r);
1752
1753 if (rc == NGX_OK) {
1754 u->cache_status = NGX_HTTP_CACHE_STALE;
1755 rc = ngx_http_upstream_cache_send(r, u);
1756 }
1757
1758 ngx_http_upstream_finalize_request(r, u, rc);
1759 return NGX_OK;
1760 }
1761
1762 #endif
1763 }
1764
1765 return NGX_DECLINED;
1766 }
1767
1768
1769 static ngx_int_t
1770 ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
1771 ngx_http_upstream_t *u)
1772 {
1773 ngx_int_t status;
1774 ngx_uint_t i;
1775 ngx_table_elt_t *h;
1776 ngx_http_err_page_t *err_page;
1777 ngx_http_core_loc_conf_t *clcf;
1778
1779 status = u->headers_in.status_n;
1780
1781 if (status == NGX_HTTP_NOT_FOUND && u->conf->intercept_404) {
1782 ngx_http_upstream_finalize_request(r, u, NGX_HTTP_NOT_FOUND);
1783 return NGX_OK;
1784 }
1785
1786 if (!u->conf->intercept_errors) {
1787 return NGX_DECLINED;
1788 }
1789
1790 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
1791
1792 if (clcf->error_pages == NULL) {
1793 return NGX_DECLINED;
1794 }
1795
1796 err_page = clcf->error_pages->elts;
1797 for (i = 0; i < clcf->error_pages->nelts; i++) {
1798
1799 if (err_page[i].status == status) {
1800
1801 if (status == NGX_HTTP_UNAUTHORIZED
1802 && u->headers_in.www_authenticate)
1803 {
1804 h = ngx_list_push(&r->headers_out.headers);
1805
1806 if (h == NULL) {
1807 ngx_http_upstream_finalize_request(r, u,
1808 NGX_HTTP_INTERNAL_SERVER_ERROR);
1809 return NGX_OK;
1810 }
1811
1812 *h = *u->headers_in.www_authenticate;
1813
1814 r->headers_out.www_authenticate = h;
1815 }
1816
1817 #if (NGX_HTTP_CACHE)
1818
1819 if (r->cache) {
1820 time_t valid;
1821
1822 valid = ngx_http_file_cache_valid(u->conf->cache_valid, status);
1823
1824 if (valid) {
1825 r->cache->valid_sec = ngx_time() + valid;
1826 r->cache->error = status;
1827 }
1828
1829 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
1830 }
1831 #endif
1832 ngx_http_upstream_finalize_request(r, u, status);
1833
1834 return NGX_OK;
1835 }
1836 }
1837
1838 return NGX_DECLINED;
1839 }
1840
1841
1842 static ngx_int_t
1843 ngx_http_upstream_test_connect(ngx_connection_t *c)
1844 {
1845 int err;
1846 socklen_t len;
1847
1848 #if (NGX_HAVE_KQUEUE)
1849
1850 if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
1851 if (c->write->pending_eof || c->read->pending_eof) {
1852 if (c->write->pending_eof) {
1853 err = c->write->kq_errno;
1854
1855 } else {
1856 err = c->read->kq_errno;
1857 }
1858
1859 c->log->action = "connecting to upstream";
1860 (void) ngx_connection_error(c, err,
1861 "kevent() reported that connect() failed");
1862 return NGX_ERROR;
1863 }
1864
1865 } else
1866 #endif
1867 {
1868 err = 0;
1869 len = sizeof(int);
1870
1871 /*
1872 * BSDs and Linux return 0 and set a pending error in err
1873 * Solaris returns -1 and sets errno
1874 */
1875
1876 if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
1877 == -1)
1878 {
1879 err = ngx_errno;
1880 }
1881
1882 if (err) {
1883 c->log->action = "connecting to upstream";
1884 (void) ngx_connection_error(c, err, "connect() failed");
1885 return NGX_ERROR;
1886 }
1887 }
1888
1889 return NGX_OK;
1890 }
1891
1892
1893 static ngx_int_t
1894 ngx_http_upstream_process_headers(ngx_http_request_t *r, ngx_http_upstream_t *u)
1895 {
1896 ngx_str_t *uri, args;
1897 ngx_uint_t i, flags;
1898 ngx_list_part_t *part;
1899 ngx_table_elt_t *h;
1900 ngx_http_upstream_header_t *hh;
1901 ngx_http_upstream_main_conf_t *umcf;
1902
1903 umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);
1904
1905 if (u->headers_in.x_accel_redirect
1906 && !(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT))
1907 {
1908 ngx_http_upstream_finalize_request(r, u, NGX_DECLINED);
1909
1910 part = &u->headers_in.headers.part;
1911 h = part->elts;
1912
1913 for (i = 0; /* void */; i++) {
1914
1915 if (i >= part->nelts) {
1916 if (part->next == NULL) {
1917 break;
1918 }
1919
1920 part = part->next;
1921 h = part->elts;
1922 i = 0;
1923 }
1924
1925 hh = ngx_hash_find(&umcf->headers_in_hash, h[i].hash,
1926 h[i].lowcase_key, h[i].key.len);
1927
1928 if (hh && hh->redirect) {
1929 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
1930 ngx_http_finalize_request(r,
1931 NGX_HTTP_INTERNAL_SERVER_ERROR);
1932 return NGX_DONE;
1933 }
1934 }
1935 }
1936
1937 uri = &u->headers_in.x_accel_redirect->value;
1938 ngx_str_null(&args);
1939 flags = NGX_HTTP_LOG_UNSAFE;
1940
1941 if (ngx_http_parse_unsafe_uri(r, uri, &args, &flags) != NGX_OK) {
1942 ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
1943 return NGX_DONE;
1944 }
1945
1946 if (r->method != NGX_HTTP_HEAD) {
1947 r->method = NGX_HTTP_GET;
1948 }
1949
1950 ngx_http_internal_redirect(r, uri, &args);
1951 ngx_http_finalize_request(r, NGX_DONE);
1952 return NGX_DONE;
1953 }
1954
1955 part = &u->headers_in.headers.part;
1956 h = part->elts;
1957
1958 for (i = 0; /* void */; i++) {
1959
1960 if (i >= part->nelts) {
1961 if (part->next == NULL) {
1962 break;
1963 }
1964
1965 part = part->next;
1966 h = part->elts;
1967 i = 0;
1968 }
1969
1970 if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
1971 h[i].lowcase_key, h[i].key.len))
1972 {
1973 continue;
1974 }
1975
1976 hh = ngx_hash_find(&umcf->headers_in_hash, h[i].hash,
1977 h[i].lowcase_key, h[i].key.len);
1978
1979 if (hh) {
1980 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
1981 ngx_http_upstream_finalize_request(r, u,
1982 NGX_HTTP_INTERNAL_SERVER_ERROR);
1983 return NGX_DONE;
1984 }
1985
1986 continue;
1987 }
1988
1989 if (ngx_http_upstream_copy_header_line(r, &h[i], 0) != NGX_OK) {
1990 ngx_http_upstream_finalize_request(r, u,
1991 NGX_HTTP_INTERNAL_SERVER_ERROR);
1992 return NGX_DONE;
1993 }
1994 }
1995
1996 if (r->headers_out.server && r->headers_out.server->value.data == NULL) {
1997 r->headers_out.server->hash = 0;
1998 }
1999
2000 if (r->headers_out.date && r->headers_out.date->value.data == NULL) {
2001 r->headers_out.date->hash = 0;
2002 }
2003
2004 r->headers_out.status = u->headers_in.status_n;
2005 r->headers_out.status_line = u->headers_in.status_line;
2006
2007 r->headers_out.content_length_n = u->headers_in.content_length_n;
2008
2009 u->length = u->headers_in.content_length_n;
2010
2011 return NGX_OK;
2012 }
2013
2014
2015 static void
2016 ngx_http_upstream_process_body_in_memory(ngx_http_request_t *r,
2017 ngx_http_upstream_t *u)
2018 {
2019 size_t size;
2020 ssize_t n;
2021 ngx_buf_t *b;
2022 ngx_event_t *rev;
2023 ngx_connection_t *c;
2024
2025 c = u->peer.connection;
2026 rev = c->read;
2027
2028 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2029 "http upstream process body on memory");
2030
2031 if (rev->timedout) {
2032 ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
2033 ngx_http_upstream_finalize_request(r, u, NGX_ETIMEDOUT);
2034 return;
2035 }
2036
2037 b = &u->buffer;
2038
2039 for ( ;; ) {
2040
2041 size = b->end - b->last;
2042
2043 if (size == 0) {
2044 ngx_log_error(NGX_LOG_ALERT, c->log, 0,
2045 "upstream buffer is too small to read response");
2046 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
2047 return;
2048 }
2049
2050 n = c->recv(c, b->last, size);
2051
2052 if (n == NGX_AGAIN) {
2053 break;
2054 }
2055
2056 if (n == 0 || n == NGX_ERROR) {
2057 ngx_http_upstream_finalize_request(r, u, n);
2058 return;
2059 }
2060
2061 u->state->response_length += n;
2062
2063 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
2064 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
2065 return;
2066 }
2067
2068 if (!rev->ready) {
2069 break;
2070 }
2071 }
2072
2073 if (u->length == 0) {
2074 ngx_http_upstream_finalize_request(r, u, 0);
2075 return;
2076 }
2077
2078 if (ngx_handle_read_event(rev, 0) != NGX_OK) {
2079 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
2080 return;
2081 }
2082
2083 if (rev->active) {
2084 ngx_add_timer(rev, u->conf->read_timeout);
2085
2086 } else if (rev->timer_set) {
2087 ngx_del_timer(rev);
2088 }
2089 }
2090
2091
2092 static void
2093 ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
2094 {
2095 int tcp_nodelay;
2096 ssize_t n;
2097 ngx_int_t rc;
2098 ngx_event_pipe_t *p;
2099 ngx_connection_t *c;
2100 ngx_http_core_loc_conf_t *clcf;
2101
2102 rc = ngx_http_send_header(r);
2103
2104 if (rc == NGX_ERROR || rc > NGX_OK || r->post_action) {
2105 ngx_http_upstream_finalize_request(r, u, rc);
2106 return;
2107 }
2108
2109 if (u->upgrade) {
2110 ngx_http_upstream_upgrade(r, u);
2111 return;
2112 }
2113
2114 c = r->connection;
2115
2116 if (r->header_only) {
2117
2118 if (u->cacheable || u->store) {
2119
2120 if (ngx_shutdown_socket(c->fd, NGX_WRITE_SHUTDOWN) == -1) {
2121 ngx_connection_error(c, ngx_socket_errno,
2122 ngx_shutdown_socket_n " failed");
2123 }
2124
2125 r->read_event_handler = ngx_http_request_empty_handler;
2126 r->write_event_handler = ngx_http_request_empty_handler;
2127 c->error = 1;
2128
2129 } else {
2130 ngx_http_upstream_finalize_request(r, u, rc);
2131 return;
2132 }
2133 }
2134
2135 u->header_sent = 1;
2136
2137 if (r->request_body && r->request_body->temp_file) {
2138 ngx_pool_run_cleanup_file(r->pool, r->request_body->temp_file->file.fd);
2139 r->request_body->temp_file->file.fd = NGX_INVALID_FILE;
2140 }
2141
2142 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
2143
2144 if (!u->buffering) {
2145
2146 if (u->input_filter == NULL) {
2147 u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
2148 u->input_filter = ngx_http_upstream_non_buffered_filter;
2149 u->input_filter_ctx = r;
2150 }
2151
2152 u->read_event_handler = ngx_http_upstream_process_non_buffered_upstream;
2153 r->write_event_handler =
2154 ngx_http_upstream_process_non_buffered_downstream;
2155
2156 r->limit_rate = 0;
2157
2158 if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
2159 ngx_http_upstream_finalize_request(r, u, 0);
2160 return;
2161 }
2162
2163 if (clcf->tcp_nodelay && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
2164 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");
2165
2166 tcp_nodelay = 1;
2167
2168 if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
2169 (const void *) &tcp_nodelay, sizeof(int)) == -1)
2170 {
2171 ngx_connection_error(c, ngx_socket_errno,
2172 "setsockopt(TCP_NODELAY) failed");
2173 ngx_http_upstream_finalize_request(r, u, 0);
2174 return;
2175 }
2176
2177 c->tcp_nodelay = NGX_TCP_NODELAY_SET;
2178 }
2179
2180 n = u->buffer.last - u->buffer.pos;
2181
2182 if (n) {
2183 u->buffer.last = u->buffer.pos;
2184
2185 u->state->response_length += n;
2186
2187 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
2188 ngx_http_upstream_finalize_request(r, u, 0);
2189 return;
2190 }
2191
2192 ngx_http_upstream_process_non_buffered_downstream(r);
2193
2194 } else {
2195 u->buffer.pos = u->buffer.start;
2196 u->buffer.last = u->buffer.start;
2197
2198 if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
2199 ngx_http_upstream_finalize_request(r, u, 0);
2200 return;
2201 }
2202
2203 if (u->peer.connection->read->ready || u->length == 0) {
2204 ngx_http_upstream_process_non_buffered_upstream(r, u);
2205 }
2206 }
2207
2208 return;
2209 }
2210
2211 /* TODO: preallocate event_pipe bufs, look "Content-Length" */
2212
2213 #if (NGX_HTTP_CACHE)
2214
2215 if (r->cache && r->cache->file.fd != NGX_INVALID_FILE) {
2216 ngx_pool_run_cleanup_file(r->pool, r->cache->file.fd);
2217 r->cache->file.fd = NGX_INVALID_FILE;
2218 }
2219
2220 switch (ngx_http_test_predicates(r, u->conf->no_cache)) {
2221
2222 case NGX_ERROR:
2223 ngx_http_upstream_finalize_request(r, u, 0);
2224 return;
2225
2226 case NGX_DECLINED:
2227 u->cacheable = 0;
2228 break;
2229
2230 default: /* NGX_OK */
2231
2232 if (u->cache_status == NGX_HTTP_CACHE_BYPASS) {
2233
2234 r->cache->min_uses = u->conf->cache_min_uses;
2235 r->cache->body_start = u->conf->buffer_size;
2236 r->cache->file_cache = u->conf->cache->data;
2237
2238 if (ngx_http_file_cache_create(r) != NGX_OK) {
2239 ngx_http_upstream_finalize_request(r, u, 0);
2240 return;
2241 }
2242 }
2243
2244 break;
2245 }
2246
2247 if (u->cacheable) {
2248 time_t now, valid;
2249
2250 now = ngx_time();
2251
2252 valid = r->cache->valid_sec;
2253
2254 if (valid == 0) {
2255 valid = ngx_http_file_cache_valid(u->conf->cache_valid,
2256 u->headers_in.status_n);
2257 if (valid) {
2258 r->cache->valid_sec = now + valid;
2259 }
2260 }
2261
2262 if (valid) {
2263 r->cache->last_modified = r->headers_out.last_modified_time;
2264 r->cache->date = now;
2265 r->cache->body_start = (u_short) (u->buffer.pos - u->buffer.start);
2266
2267 ngx_http_file_cache_set_header(r, u->buffer.start);
2268
2269 } else {
2270 u->cacheable = 0;
2271 r->headers_out.last_modified_time = -1;
2272 }
2273 }
2274
2275 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
2276 "http cacheable: %d", u->cacheable);
2277
2278 if (u->cacheable == 0 && r->cache) {
2279 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
2280 }
2281
2282 #endif
2283
2284 p = u->pipe;
2285
2286 p->output_filter = (ngx_event_pipe_output_filter_pt) ngx_http_output_filter;
2287 p->output_ctx = r;
2288 p->tag = u->output.tag;
2289 p->bufs = u->conf->bufs;
2290 p->busy_size = u->conf->busy_buffers_size;
2291 p->upstream = u->peer.connection;
2292 p->downstream = c;
2293 p->pool = r->pool;
2294 p->log = c->log;
2295
2296 p->cacheable = u->cacheable || u->store;
2297
2298 p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
2299 if (p->temp_file == NULL) {
2300 ngx_http_upstream_finalize_request(r, u, 0);
2301 return;
2302 }
2303
2304 p->temp_file->file.fd = NGX_INVALID_FILE;
2305 p->temp_file->file.log = c->log;
2306 p->temp_file->path = u->conf->temp_path;
2307 p->temp_file->pool = r->pool;
2308
2309 if (p->cacheable) {
2310 p->temp_file->persistent = 1;
2311
2312 } else {
2313 p->temp_file->log_level = NGX_LOG_WARN;
2314 p->temp_file->warn = "an upstream response is buffered "
2315 "to a temporary file";
2316 }
2317
2318 p->max_temp_file_size = u->conf->max_temp_file_size;
2319 p->temp_file_write_size = u->conf->temp_file_write_size;
2320
2321 p->preread_bufs = ngx_alloc_chain_link(r->pool);
2322 if (p->preread_bufs == NULL) {
2323 ngx_http_upstream_finalize_request(r, u, 0);
2324 return;
2325 }
2326
2327 p->preread_bufs->buf = &u->buffer;
2328 p->preread_bufs->next = NULL;
2329 u->buffer.recycled = 1;
2330
2331 p->preread_size = u->buffer.last - u->buffer.pos;
2332
2333 if (u->cacheable) {
2334
2335 p->buf_to_file = ngx_calloc_buf(r->pool);
2336 if (p->buf_to_file == NULL) {
2337 ngx_http_upstream_finalize_request(r, u, 0);
2338 return;
2339 }
2340
2341 p->buf_to_file->start = u->buffer.start;
2342 p->buf_to_file->pos = u->buffer.start;
2343 p->buf_to_file->last = u->buffer.pos;
2344 p->buf_to_file->temporary = 1;
2345 }
2346
2347 if (ngx_event_flags & NGX_USE_AIO_EVENT) {
2348 /* the posted aio operation may corrupt a shadow buffer */
2349 p->single_buf = 1;
2350 }
2351
2352 /* TODO: p->free_bufs = 0 if use ngx_create_chain_of_bufs() */
2353 p->free_bufs = 1;
2354
2355 /*
2356 * event_pipe would do u->buffer.last += p->preread_size
2357 * as though these bytes were read
2358 */
2359 u->buffer.last = u->buffer.pos;
2360
2361 if (u->conf->cyclic_temp_file) {
2362
2363 /*
2364 * we need to disable the use of sendfile() if we use cyclic temp file
2365 * because the writing a new data may interfere with sendfile()
2366 * that uses the same kernel file pages (at least on FreeBSD)
2367 */
2368
2369 p->cyclic_temp_file = 1;
2370 c->sendfile = 0;
2371
2372 } else {
2373 p->cyclic_temp_file = 0;
2374 }
2375
2376 p->read_timeout = u->conf->read_timeout;
2377 p->send_timeout = clcf->send_timeout;
2378 p->send_lowat = clcf->send_lowat;
2379
2380 p->length = -1;
2381
2382 if (u->input_filter_init
2383 && u->input_filter_init(p->input_ctx) != NGX_OK)
2384 {
2385 ngx_http_upstream_finalize_request(r, u, 0);
2386 return;
2387 }
2388
2389 u->read_event_handler = ngx_http_upstream_process_upstream;
2390 r->write_event_handler = ngx_http_upstream_process_downstream;
2391
2392 ngx_http_upstream_process_upstream(r, u);
2393 }
2394
2395
2396 static void
2397 ngx_http_upstream_upgrade(ngx_http_request_t *r, ngx_http_upstream_t *u)
2398 {
2399 int tcp_nodelay;
2400 ngx_connection_t *c;
2401 ngx_http_core_loc_conf_t *clcf;
2402
2403 c = r->connection;
2404 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
2405
2406 /* TODO: prevent upgrade if not requested or not possible */
2407
2408 r->keepalive = 0;
2409 c->log->action = "proxying upgraded connection";
2410
2411 u->read_event_handler = ngx_http_upstream_upgraded_read_upstream;
2412 u->write_event_handler = ngx_http_upstream_upgraded_write_upstream;
2413 r->read_event_handler = ngx_http_upstream_upgraded_read_downstream;
2414 r->write_event_handler = ngx_http_upstream_upgraded_write_downstream;
2415
2416 if (clcf->tcp_nodelay) {
2417 tcp_nodelay = 1;
2418
2419 if (c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
2420 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");
2421
2422 if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
2423 (const void *) &tcp_nodelay, sizeof(int)) == -1)
2424 {
2425 ngx_connection_error(c, ngx_socket_errno,
2426 "setsockopt(TCP_NODELAY) failed");
2427 ngx_http_upstream_finalize_request(r, u, 0);
2428 return;
2429 }
2430
2431 c->tcp_nodelay = NGX_TCP_NODELAY_SET;
2432 }
2433
2434 if (u->peer.connection->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
2435 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, u->peer.connection->log, 0,
2436 "tcp_nodelay");
2437
2438 if (setsockopt(u->peer.connection->fd, IPPROTO_TCP, TCP_NODELAY,
2439 (const void *) &tcp_nodelay, sizeof(int)) == -1)
2440 {
2441 ngx_connection_error(u->peer.connection, ngx_socket_errno,
2442 "setsockopt(TCP_NODELAY) failed");
2443 ngx_http_upstream_finalize_request(r, u, 0);
2444 return;
2445 }
2446
2447 u->peer.connection->tcp_nodelay = NGX_TCP_NODELAY_SET;
2448 }
2449 }
2450
2451 if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
2452 ngx_http_upstream_finalize_request(r, u, 0);
2453 return;
2454 }
2455
2456 if (u->peer.connection->read->ready
2457 || u->buffer.pos != u->buffer.last)
2458 {
2459 ngx_http_upstream_process_upgraded(r, 1, 1);
2460 }
2461
2462 if (c->read->ready
2463 || r->header_in->pos != r->header_in->last)
2464 {
2465 ngx_http_upstream_process_upgraded(r, 0, 1);
2466 }
2467 }
2468
2469
2470 static void
2471 ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r)
2472 {
2473 ngx_http_upstream_process_upgraded(r, 0, 0);
2474 }
2475
2476
2477 static void
2478 ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r)
2479 {
2480 ngx_http_upstream_process_upgraded(r, 1, 1);
2481 }
2482
2483
2484 static void
2485 ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
2486 ngx_http_upstream_t *u)
2487 {
2488 ngx_http_upstream_process_upgraded(r, 1, 0);
2489 }
2490
2491
2492 static void
2493 ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
2494 ngx_http_upstream_t *u)
2495 {
2496 ngx_http_upstream_process_upgraded(r, 0, 1);
2497 }
2498
2499
2500 static void
2501 ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
2502 ngx_uint_t from_upstream, ngx_uint_t do_write)
2503 {
2504 size_t size;
2505 ssize_t n;
2506 ngx_buf_t *b;
2507 ngx_connection_t *c, *downstream, *upstream, *dst, *src;
2508 ngx_http_upstream_t *u;
2509 ngx_http_core_loc_conf_t *clcf;
2510
2511 c = r->connection;
2512 u = r->upstream;
2513
2514 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
2515 "http upstream process upgraded, fu:%ui", from_upstream);
2516
2517 downstream = c;
2518 upstream = u->peer.connection;
2519
2520 if (downstream->write->timedout) {
2521 c->timedout = 1;
2522 ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
2523 ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
2524 return;
2525 }
2526
2527 if (upstream->read->timedout || upstream->write->timedout) {
2528 ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
2529 ngx_http_upstream_finalize_request(r, u, 0);
2530 return;
2531 }
2532
2533 if (from_upstream) {
2534 src = upstream;
2535 dst = downstream;
2536 b = &u->buffer;
2537
2538 } else {
2539 src = downstream;
2540 dst = upstream;
2541 b = &u->from_client;
2542
2543 if (r->header_in->last > r->header_in->pos) {
2544 b = r->header_in;
2545 b->end = b->last;
2546 do_write = 1;
2547 }
2548
2549 if (b->start == NULL) {
2550 b->start = ngx_palloc(r->pool, u->conf->buffer_size);
2551 if (b->start == NULL) {
2552 ngx_http_upstream_finalize_request(r, u, 0);
2553 return;
2554 }
2555
2556 b->pos = b->start;
2557 b->last = b->start;
2558 b->end = b->start + u->conf->buffer_size;
2559 b->temporary = 1;
2560 b->tag = u->output.tag;
2561 }
2562 }
2563
2564 for ( ;; ) {
2565
2566 if (do_write) {
2567
2568 size = b->last - b->pos;
2569
2570 if (size && dst->write->ready) {
2571
2572 n = dst->send(dst, b->pos, size);
2573
2574 if (n == NGX_ERROR) {
2575 ngx_http_upstream_finalize_request(r, u, 0);
2576 return;
2577 }
2578
2579 if (n > 0) {
2580 b->pos += n;
2581
2582 if (b->pos == b->last) {
2583 b->pos = b->start;
2584 b->last = b->start;
2585 }
2586 }
2587 }
2588 }
2589
2590 size = b->end - b->last;
2591
2592 if (size && src->read->ready) {
2593
2594 n = src->recv(src, b->last, size);
2595
2596 if (n == NGX_AGAIN || n == 0) {
2597 break;
2598 }
2599
2600 if (n > 0) {
2601 do_write = 1;
2602 b->last += n;
2603
2604 continue;
2605 }
2606
2607 if (n == NGX_ERROR) {
2608 src->read->eof = 1;
2609 }
2610 }
2611
2612 break;
2613 }
2614
2615 if ((upstream->read->eof && u->buffer.pos == u->buffer.last)
2616 || (downstream->read->eof && u->from_client.pos == u->from_client.last)
2617 || (downstream->read->eof && upstream->read->eof))
2618 {
2619 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2620 "http upstream upgraded done");
2621 ngx_http_upstream_finalize_request(r, u, 0);
2622 return;
2623 }
2624
2625 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
2626
2627 if (ngx_handle_write_event(upstream->write, u->conf->send_lowat)
2628 != NGX_OK)
2629 {
2630 ngx_http_upstream_finalize_request(r, u, 0);
2631 return;
2632 }
2633
2634 if (upstream->write->active && !upstream->write->ready) {
2635 ngx_add_timer(upstream->write, u->conf->send_timeout);
2636
2637 } else if (upstream->write->timer_set) {
2638 ngx_del_timer(upstream->write);
2639 }
2640
2641 if (ngx_handle_read_event(upstream->read, 0) != NGX_OK) {
2642 ngx_http_upstream_finalize_request(r, u, 0);
2643 return;
2644 }
2645
2646 if (upstream->read->active && !upstream->read->ready) {
2647 ngx_add_timer(upstream->read, u->conf->read_timeout);
2648
2649 } else if (upstream->read->timer_set) {
2650 ngx_del_timer(upstream->read);
2651 }
2652
2653 if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
2654 != NGX_OK)
2655 {
2656 ngx_http_upstream_finalize_request(r, u, 0);
2657 return;
2658 }
2659
2660 if (ngx_handle_read_event(downstream->read, 0) != NGX_OK) {
2661 ngx_http_upstream_finalize_request(r, u, 0);
2662 return;
2663 }
2664
2665 if (downstream->write->active && !downstream->write->ready) {
2666 ngx_add_timer(downstream->write, clcf->send_timeout);
2667
2668 } else if (downstream->write->timer_set) {
2669 ngx_del_timer(downstream->write);
2670 }
2671 }
2672
2673
2674 static void
2675 ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r)
2676 {
2677 ngx_event_t *wev;
2678 ngx_connection_t *c;
2679 ngx_http_upstream_t *u;
2680
2681 c = r->connection;
2682 u = r->upstream;
2683 wev = c->write;
2684
2685 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2686 "http upstream process non buffered downstream");
2687
2688 c->log->action = "sending to client";
2689
2690 if (wev->timedout) {
2691 c->timedout = 1;
2692 ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
2693 ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
2694 return;
2695 }
2696
2697 ngx_http_upstream_process_non_buffered_request(r, 1);
2698 }
2699
2700
2701 static void
2702 ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
2703 ngx_http_upstream_t *u)
2704 {
2705 ngx_connection_t *c;
2706
2707 c = u->peer.connection;
2708
2709 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2710 "http upstream process non buffered upstream");
2711
2712 c->log->action = "reading upstream";
2713
2714 if (c->read->timedout) {
2715 ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
2716 ngx_http_upstream_finalize_request(r, u, 0);
2717 return;
2718 }
2719
2720 ngx_http_upstream_process_non_buffered_request(r, 0);
2721 }
2722
2723
2724 static void
2725 ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
2726 ngx_uint_t do_write)
2727 {
2728 size_t size;
2729 ssize_t n;
2730 ngx_buf_t *b;
2731 ngx_int_t rc;
2732 ngx_connection_t *downstream, *upstream;
2733 ngx_http_upstream_t *u;
2734 ngx_http_core_loc_conf_t *clcf;
2735
2736 u = r->upstream;
2737 downstream = r->connection;
2738 upstream = u->peer.connection;
2739
2740 b = &u->buffer;
2741
2742 do_write = do_write || u->length == 0;
2743
2744 for ( ;; ) {
2745
2746 if (do_write) {
2747
2748 if (u->out_bufs || u->busy_bufs) {
2749 rc = ngx_http_output_filter(r, u->out_bufs);
2750
2751 if (rc == NGX_ERROR) {
2752 ngx_http_upstream_finalize_request(r, u, 0);
2753 return;
2754 }
2755
2756 ngx_chain_update_chains(r->pool, &u->free_bufs, &u->busy_bufs,
2757 &u->out_bufs, u->output.tag);
2758 }
2759
2760 if (u->busy_bufs == NULL) {
2761
2762 if (u->length == 0
2763 || upstream->read->eof
2764 || upstream->read->error)
2765 {
2766 ngx_http_upstream_finalize_request(r, u, 0);
2767 return;
2768 }
2769
2770 b->pos = b->start;
2771 b->last = b->start;
2772 }
2773 }
2774
2775 size = b->end - b->last;
2776
2777 if (size && upstream->read->ready) {
2778
2779 n = upstream->recv(upstream, b->last, size);
2780
2781 if (n == NGX_AGAIN) {
2782 break;
2783 }
2784
2785 if (n > 0) {
2786 u->state->response_length += n;
2787
2788 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
2789 ngx_http_upstream_finalize_request(r, u, 0);
2790 return;
2791 }
2792 }
2793
2794 do_write = 1;
2795
2796 continue;
2797 }
2798
2799 break;
2800 }
2801
2802 clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
2803
2804 if (downstream->data == r) {
2805 if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
2806 != NGX_OK)
2807 {
2808 ngx_http_upstream_finalize_request(r, u, 0);
2809 return;
2810 }
2811 }
2812
2813 if (downstream->write->active && !downstream->write->ready) {
2814 ngx_add_timer(downstream->write, clcf->send_timeout);
2815
2816 } else if (downstream->write->timer_set) {
2817 ngx_del_timer(downstream->write);
2818 }
2819
2820 if (ngx_handle_read_event(upstream->read, 0) != NGX_OK) {
2821 ngx_http_upstream_finalize_request(r, u, 0);
2822 return;
2823 }
2824
2825 if (upstream->read->active && !upstream->read->ready) {
2826 ngx_add_timer(upstream->read, u->conf->read_timeout);
2827
2828 } else if (upstream->read->timer_set) {
2829 ngx_del_timer(upstream->read);
2830 }
2831 }
2832
2833
2834 static ngx_int_t
2835 ngx_http_upstream_non_buffered_filter_init(void *data)
2836 {
2837 return NGX_OK;
2838 }
2839
2840
2841 static ngx_int_t
2842 ngx_http_upstream_non_buffered_filter(void *data, ssize_t bytes)
2843 {
2844 ngx_http_request_t *r = data;
2845
2846 ngx_buf_t *b;
2847 ngx_chain_t *cl, **ll;
2848 ngx_http_upstream_t *u;
2849
2850 u = r->upstream;
2851
2852 for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
2853 ll = &cl->next;
2854 }
2855
2856 cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
2857 if (cl == NULL) {
2858 return NGX_ERROR;
2859 }
2860
2861 *ll = cl;
2862
2863 cl->buf->flush = 1;
2864 cl->buf->memory = 1;
2865
2866 b = &u->buffer;
2867
2868 cl->buf->pos = b->last;
2869 b->last += bytes;
2870 cl->buf->last = b->last;
2871 cl->buf->tag = u->output.tag;
2872
2873 if (u->length == -1) {
2874 return NGX_OK;
2875 }
2876
2877 u->length -= bytes;
2878
2879 return NGX_OK;
2880 }
2881
2882
2883 static void
2884 ngx_http_upstream_process_downstream(ngx_http_request_t *r)
2885 {
2886 ngx_event_t *wev;
2887 ngx_connection_t *c;
2888 ngx_event_pipe_t *p;
2889 ngx_http_upstream_t *u;
2890
2891 c = r->connection;
2892 u = r->upstream;
2893 p = u->pipe;
2894 wev = c->write;
2895
2896 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2897 "http upstream process downstream");
2898
2899 c->log->action = "sending to client";
2900
2901 if (wev->timedout) {
2902
2903 if (wev->delayed) {
2904
2905 wev->timedout = 0;
2906 wev->delayed = 0;
2907
2908 if (!wev->ready) {
2909 ngx_add_timer(wev, p->send_timeout);
2910
2911 if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
2912 ngx_http_upstream_finalize_request(r, u, 0);
2913 }
2914
2915 return;
2916 }
2917
2918 if (ngx_event_pipe(p, wev->write) == NGX_ABORT) {
2919 ngx_http_upstream_finalize_request(r, u, 0);
2920 return;
2921 }
2922
2923 } else {
2924 p->downstream_error = 1;
2925 c->timedout = 1;
2926 ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
2927 }
2928
2929 } else {
2930
2931 if (wev->delayed) {
2932
2933 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2934 "http downstream delayed");
2935
2936 if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
2937 ngx_http_upstream_finalize_request(r, u, 0);
2938 }
2939
2940 return;
2941 }
2942
2943 if (ngx_event_pipe(p, 1) == NGX_ABORT) {
2944 ngx_http_upstream_finalize_request(r, u, 0);
2945 return;
2946 }
2947 }
2948
2949 ngx_http_upstream_process_request(r);
2950 }
2951
2952
2953 static void
2954 ngx_http_upstream_process_upstream(ngx_http_request_t *r,
2955 ngx_http_upstream_t *u)
2956 {
2957 ngx_connection_t *c;
2958
2959 c = u->peer.connection;
2960
2961 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
2962 "http upstream process upstream");
2963
2964 c->log->action = "reading upstream";
2965
2966 if (c->read->timedout) {
2967 u->pipe->upstream_error = 1;
2968 ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
2969
2970 } else {
2971 if (ngx_event_pipe(u->pipe, 0) == NGX_ABORT) {
2972 ngx_http_upstream_finalize_request(r, u, 0);
2973 return;
2974 }
2975 }
2976
2977 ngx_http_upstream_process_request(r);
2978 }
2979
2980
2981 static void
2982 ngx_http_upstream_process_request(ngx_http_request_t *r)
2983 {
2984 ngx_temp_file_t *tf;
2985 ngx_event_pipe_t *p;
2986 ngx_http_upstream_t *u;
2987
2988 u = r->upstream;
2989 p = u->pipe;
2990
2991 if (u->peer.connection) {
2992
2993 if (u->store) {
2994
2995 if (p->upstream_eof || p->upstream_done) {
2996
2997 tf = u->pipe->temp_file;
2998
2999 if (u->headers_in.status_n == NGX_HTTP_OK
3000 && (u->headers_in.content_length_n == -1
3001 || (u->headers_in.content_length_n == tf->offset)))
3002 {
3003 ngx_http_upstream_store(r, u);
3004 u->store = 0;
3005 }
3006 }
3007 }
3008
3009 #if (NGX_HTTP_CACHE)
3010
3011 if (u->cacheable) {
3012
3013 if (p->upstream_done) {
3014 ngx_http_file_cache_update(r, u->pipe->temp_file);
3015
3016 } else if (p->upstream_eof) {
3017
3018 tf = u->pipe->temp_file;
3019
3020 if (u->headers_in.content_length_n == -1
3021 || u->headers_in.content_length_n
3022 == tf->offset - (off_t) r->cache->body_start)
3023 {
3024 ngx_http_file_cache_update(r, tf);
3025
3026 } else {
3027 ngx_http_file_cache_free(r->cache, tf);
3028 }
3029
3030 } else if (p->upstream_error) {
3031 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
3032 }
3033 }
3034
3035 #endif
3036
3037 if (p->upstream_done || p->upstream_eof || p->upstream_error) {
3038 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3039 "http upstream exit: %p", p->out);
3040 #if 0
3041 ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
3042 #endif
3043 ngx_http_upstream_finalize_request(r, u, 0);
3044 return;
3045 }
3046 }
3047
3048 if (p->downstream_error) {
3049 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3050 "http upstream downstream error");
3051
3052 if (!u->cacheable && !u->store && u->peer.connection) {
3053 ngx_http_upstream_finalize_request(r, u, 0);
3054 }
3055 }
3056 }
3057
3058
3059 static void
3060 ngx_http_upstream_store(ngx_http_request_t *r, ngx_http_upstream_t *u)
3061 {
3062 size_t root;
3063 time_t lm;
3064 ngx_str_t path;
3065 ngx_temp_file_t *tf;
3066 ngx_ext_rename_file_t ext;
3067
3068 tf = u->pipe->temp_file;
3069
3070 if (tf->file.fd == NGX_INVALID_FILE) {
3071
3072 /* create file for empty 200 response */
3073
3074 tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
3075 if (tf == NULL) {
3076 return;
3077 }
3078
3079 tf->file.fd = NGX_INVALID_FILE;
3080 tf->file.log = r->connection->log;
3081 tf->path = u->conf->temp_path;
3082 tf->pool = r->pool;
3083 tf->persistent = 1;
3084
3085 if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
3086 tf->persistent, tf->clean, tf->access)
3087 != NGX_OK)
3088 {
3089 return;
3090 }
3091
3092 u->pipe->temp_file = tf;
3093 }
3094
3095 ext.access = u->conf->store_access;
3096 ext.path_access = u->conf->store_access;
3097 ext.time = -1;
3098 ext.create_path = 1;
3099 ext.delete_file = 1;
3100 ext.log = r->connection->log;
3101
3102 if (u->headers_in.last_modified) {
3103
3104 lm = ngx_http_parse_time(u->headers_in.last_modified->value.data,
3105 u->headers_in.last_modified->value.len);
3106
3107 if (lm != NGX_ERROR) {
3108 ext.time = lm;
3109 ext.fd = tf->file.fd;
3110 }
3111 }
3112
3113 if (u->conf->store_lengths == NULL) {
3114
3115 ngx_http_map_uri_to_path(r, &path, &root, 0);
3116
3117 } else {
3118 if (ngx_http_script_run(r, &path, u->conf->store_lengths->elts, 0,
3119 u->conf->store_values->elts)
3120 == NULL)
3121 {
3122 return;
3123 }
3124 }
3125
3126 path.len--;
3127
3128 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3129 "upstream stores \"%s\" to \"%s\"",
3130 tf->file.name.data, path.data);
3131
3132 (void) ngx_ext_rename_file(&tf->file.name, &path, &ext);
3133 }
3134
3135
3136 static void
3137 ngx_http_upstream_dummy_handler(ngx_http_request_t *r, ngx_http_upstream_t *u)
3138 {
3139 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3140 "http upstream dummy handler");
3141 }
3142
3143
3144 static void
3145 ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
3146 ngx_uint_t ft_type)
3147 {
3148 ngx_uint_t status, state;
3149
3150 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3151 "http next upstream, %xi", ft_type);
3152
3153 #if 0
3154 ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
3155 #endif
3156
3157 if (u->peer.sockaddr) {
3158
3159 if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404) {
3160 state = NGX_PEER_NEXT;
3161 } else {
3162 state = NGX_PEER_FAILED;
3163 }
3164
3165 u->peer.free(&u->peer, u->peer.data, state);
3166 u->peer.sockaddr = NULL;
3167 }
3168
3169 if (ft_type == NGX_HTTP_UPSTREAM_FT_TIMEOUT) {
3170 ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ETIMEDOUT,
3171 "upstream timed out");
3172 }
3173
3174 if (u->peer.cached && ft_type == NGX_HTTP_UPSTREAM_FT_ERROR) {
3175 status = 0;
3176
3177 /* TODO: inform balancer instead */
3178
3179 u->peer.tries++;
3180
3181 } else {
3182 switch(ft_type) {
3183
3184 case NGX_HTTP_UPSTREAM_FT_TIMEOUT:
3185 status = NGX_HTTP_GATEWAY_TIME_OUT;
3186 break;
3187
3188 case NGX_HTTP_UPSTREAM_FT_HTTP_500:
3189 status = NGX_HTTP_INTERNAL_SERVER_ERROR;
3190 break;
3191
3192 case NGX_HTTP_UPSTREAM_FT_HTTP_404:
3193 status = NGX_HTTP_NOT_FOUND;
3194 break;
3195
3196 /*
3197 * NGX_HTTP_UPSTREAM_FT_BUSY_LOCK and NGX_HTTP_UPSTREAM_FT_MAX_WAITING
3198 * never reach here
3199 */
3200
3201 default:
3202 status = NGX_HTTP_BAD_GATEWAY;
3203 }
3204 }
3205
3206 if (r->connection->error) {
3207 ngx_http_upstream_finalize_request(r, u,
3208 NGX_HTTP_CLIENT_CLOSED_REQUEST);
3209 return;
3210 }
3211
3212 if (status) {
3213 u->state->status = status;
3214
3215 if (u->peer.tries == 0 || !(u->conf->next_upstream & ft_type)) {
3216
3217 #if (NGX_HTTP_CACHE)
3218
3219 if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
3220 && (u->conf->cache_use_stale & ft_type))
3221 {
3222 ngx_int_t rc;
3223
3224 rc = u->reinit_request(r);
3225
3226 if (rc == NGX_OK) {
3227 u->cache_status = NGX_HTTP_CACHE_STALE;
3228 rc = ngx_http_upstream_cache_send(r, u);
3229 }
3230
3231 ngx_http_upstream_finalize_request(r, u, rc);
3232 return;
3233 }
3234 #endif
3235
3236 ngx_http_upstream_finalize_request(r, u, status);
3237 return;
3238 }
3239 }
3240
3241 if (u->peer.connection) {
3242 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3243 "close http upstream connection: %d",
3244 u->peer.connection->fd);
3245 #if (NGX_HTTP_SSL)
3246
3247 if (u->peer.connection->ssl) {
3248 u->peer.connection->ssl->no_wait_shutdown = 1;
3249 u->peer.connection->ssl->no_send_shutdown = 1;
3250
3251 (void) ngx_ssl_shutdown(u->peer.connection);
3252 }
3253 #endif
3254
3255 if (u->peer.connection->pool) {
3256 ngx_destroy_pool(u->peer.connection->pool);
3257 }
3258
3259 ngx_close_connection(u->peer.connection);
3260 u->peer.connection = NULL;
3261 }
3262
3263 #if 0
3264 if (u->conf->busy_lock && !u->busy_locked) {
3265 ngx_http_upstream_busy_lock(p);
3266 return;
3267 }
3268 #endif
3269
3270 ngx_http_upstream_connect(r, u);
3271 }
3272
3273
3274 static void
3275 ngx_http_upstream_cleanup(void *data)
3276 {
3277 ngx_http_request_t *r = data;
3278
3279 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3280 "cleanup http upstream request: \"%V\"", &r->uri);
3281
3282 ngx_http_upstream_finalize_request(r, r->upstream, NGX_DONE);
3283 }
3284
3285
3286 static void
3287 ngx_http_upstream_finalize_request(ngx_http_request_t *r,
3288 ngx_http_upstream_t *u, ngx_int_t rc)
3289 {
3290 ngx_time_t *tp;
3291
3292 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3293 "finalize http upstream request: %i", rc);
3294
3295 if (u->cleanup) {
3296 *u->cleanup = NULL;
3297 u->cleanup = NULL;
3298 }
3299
3300 if (u->resolved && u->resolved->ctx) {
3301 ngx_resolve_name_done(u->resolved->ctx);
3302 u->resolved->ctx = NULL;
3303 }
3304
3305 if (u->state && u->state->response_sec) {
3306 tp = ngx_timeofday();
3307 u->state->response_sec = tp->sec - u->state->response_sec;
3308 u->state->response_msec = tp->msec - u->state->response_msec;
3309
3310 if (u->pipe && u->pipe->read_length) {
3311 u->state->response_length = u->pipe->read_length;
3312 }
3313 }
3314
3315 u->finalize_request(r, rc);
3316
3317 if (u->peer.free && u->peer.sockaddr) {
3318 u->peer.free(&u->peer, u->peer.data, 0);
3319 u->peer.sockaddr = NULL;
3320 }
3321
3322 if (u->peer.connection) {
3323
3324 #if (NGX_HTTP_SSL)
3325
3326 /* TODO: do not shutdown persistent connection */
3327
3328 if (u->peer.connection->ssl) {
3329
3330 /*
3331 * We send the "close notify" shutdown alert to the upstream only
3332 * and do not wait its "close notify" shutdown alert.
3333 * It is acceptable according to the TLS standard.
3334 */
3335
3336 u->peer.connection->ssl->no_wait_shutdown = 1;
3337
3338 (void) ngx_ssl_shutdown(u->peer.connection);
3339 }
3340 #endif
3341
3342 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3343 "close http upstream connection: %d",
3344 u->peer.connection->fd);
3345
3346 if (u->peer.connection->pool) {
3347 ngx_destroy_pool(u->peer.connection->pool);
3348 }
3349
3350 ngx_close_connection(u->peer.connection);
3351 }
3352
3353 u->peer.connection = NULL;
3354
3355 if (u->pipe && u->pipe->temp_file) {
3356 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3357 "http upstream temp fd: %d",
3358 u->pipe->temp_file->file.fd);
3359 }
3360
3361 if (u->store && u->pipe && u->pipe->temp_file
3362 && u->pipe->temp_file->file.fd != NGX_INVALID_FILE)
3363 {
3364 if (ngx_delete_file(u->pipe->temp_file->file.name.data)
3365 == NGX_FILE_ERROR)
3366 {
3367 ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
3368 ngx_delete_file_n " \"%s\" failed",
3369 u->pipe->temp_file->file.name.data);
3370 }
3371 }
3372
3373 #if (NGX_HTTP_CACHE)
3374
3375 if (r->cache) {
3376
3377 if (u->cacheable) {
3378
3379 if (rc == NGX_HTTP_BAD_GATEWAY || rc == NGX_HTTP_GATEWAY_TIME_OUT) {
3380 time_t valid;
3381
3382 valid = ngx_http_file_cache_valid(u->conf->cache_valid, rc);
3383
3384 if (valid) {
3385 r->cache->valid_sec = ngx_time() + valid;
3386 r->cache->error = rc;
3387 }
3388 }
3389 }
3390
3391 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
3392 }
3393
3394 #endif
3395
3396 if (u->header_sent
3397 && rc != NGX_HTTP_REQUEST_TIME_OUT
3398 && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
3399 {
3400 rc = 0;
3401 }
3402
3403 if (rc == NGX_DECLINED) {
3404 return;
3405 }
3406
3407 r->connection->log->action = "sending to client";
3408
3409 if (rc == 0
3410 && !r->header_only
3411 #if (NGX_HTTP_CACHE)
3412 && !r->cached
3413 #endif
3414 )
3415 {
3416 rc = ngx_http_send_special(r, NGX_HTTP_LAST);
3417 }
3418
3419 ngx_http_finalize_request(r, rc);
3420 }
3421
3422
3423 static ngx_int_t
3424 ngx_http_upstream_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
3425 ngx_uint_t offset)
3426 {
3427 ngx_table_elt_t **ph;
3428
3429 ph = (ngx_table_elt_t **) ((char *) &r->upstream->headers_in + offset);
3430
3431 if (*ph == NULL) {
3432 *ph = h;
3433 }
3434
3435 return NGX_OK;
3436 }
3437
3438
3439 static ngx_int_t
3440 ngx_http_upstream_ignore_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
3441 ngx_uint_t offset)
3442 {
3443 return NGX_OK;
3444 }
3445
3446
3447 static ngx_int_t
3448 ngx_http_upstream_process_content_length(ngx_http_request_t *r,
3449 ngx_table_elt_t *h, ngx_uint_t offset)
3450 {
3451 ngx_http_upstream_t *u;
3452
3453 u = r->upstream;
3454
3455 u->headers_in.content_length = h;
3456 u->headers_in.content_length_n = ngx_atoof(h->value.data, h->value.len);
3457
3458 return NGX_OK;
3459 }
3460
3461
3462 static ngx_int_t
3463 ngx_http_upstream_process_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
3464 ngx_uint_t offset)
3465 {
3466 #if (NGX_HTTP_CACHE)
3467 ngx_http_upstream_t *u;
3468
3469 u = r->upstream;
3470
3471 if (!(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_SET_COOKIE)) {
3472 u->cacheable = 0;
3473 }
3474 #endif
3475
3476 return NGX_OK;
3477 }
3478
3479
3480 static ngx_int_t
3481 ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
3482 ngx_table_elt_t *h, ngx_uint_t offset)
3483 {
3484 ngx_array_t *pa;
3485 ngx_table_elt_t **ph;
3486 ngx_http_upstream_t *u;
3487
3488 u = r->upstream;
3489 pa = &u->headers_in.cache_control;
3490
3491 if (pa->elts == NULL) {
3492 if (ngx_array_init(pa, r->pool, 2, sizeof(ngx_table_elt_t *)) != NGX_OK)
3493 {
3494 return NGX_ERROR;
3495 }
3496 }
3497
3498 ph = ngx_array_push(pa);
3499 if (ph == NULL) {
3500 return NGX_ERROR;
3501 }
3502
3503 *ph = h;
3504
3505 #if (NGX_HTTP_CACHE)
3506 {
3507 u_char *p, *last;
3508 ngx_int_t n;
3509
3510 if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL) {
3511 return NGX_OK;
3512 }
3513
3514 if (r->cache == NULL) {
3515 return NGX_OK;
3516 }
3517
3518 if (r->cache->valid_sec != 0) {
3519 return NGX_OK;
3520 }
3521
3522 p = h->value.data;
3523 last = p + h->value.len;
3524
3525 if (ngx_strlcasestrn(p, last, (u_char *) "no-cache", 8 - 1) != NULL
3526 || ngx_strlcasestrn(p, last, (u_char *) "no-store", 8 - 1) != NULL
3527 || ngx_strlcasestrn(p, last, (u_char *) "private", 7 - 1) != NULL)
3528 {
3529 u->cacheable = 0;
3530 return NGX_OK;
3531 }
3532
3533 p = ngx_strlcasestrn(p, last, (u_char *) "max-age=", 8 - 1);
3534
3535 if (p == NULL) {
3536 return NGX_OK;
3537 }
3538
3539 n = 0;
3540
3541 for (p += 8; p < last; p++) {
3542 if (*p == ',' || *p == ';' || *p == ' ') {
3543 break;
3544 }
3545
3546 if (*p >= '0' && *p <= '9') {
3547 n = n * 10 + *p - '0';
3548 continue;
3549 }
3550
3551 u->cacheable = 0;
3552 return NGX_OK;
3553 }
3554
3555 if (n == 0) {
3556 u->cacheable = 0;
3557 return NGX_OK;
3558 }
3559
3560 r->cache->valid_sec = ngx_time() + n;
3561 }
3562 #endif
3563
3564 return NGX_OK;
3565 }
3566
3567
3568 static ngx_int_t
3569 ngx_http_upstream_process_expires(ngx_http_request_t *r, ngx_table_elt_t *h,
3570 ngx_uint_t offset)
3571 {
3572 ngx_http_upstream_t *u;
3573
3574 u = r->upstream;
3575 u->headers_in.expires = h;
3576
3577 #if (NGX_HTTP_CACHE)
3578 {
3579 time_t expires;
3580
3581 if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_EXPIRES) {
3582 return NGX_OK;
3583 }
3584
3585 if (r->cache == NULL) {
3586 return NGX_OK;
3587 }
3588
3589 if (r->cache->valid_sec != 0) {
3590 return NGX_OK;
3591 }
3592
3593 expires = ngx_http_parse_time(h->value.data, h->value.len);
3594
3595 if (expires == NGX_ERROR || expires < ngx_time()) {
3596 u->cacheable = 0;
3597 return NGX_OK;
3598 }
3599
3600 r->cache->valid_sec = expires;
3601 }
3602 #endif
3603
3604 return NGX_OK;
3605 }
3606
3607
3608 static ngx_int_t
3609 ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
3610 ngx_table_elt_t *h, ngx_uint_t offset)
3611 {
3612 ngx_http_upstream_t *u;
3613
3614 u = r->upstream;
3615 u->headers_in.x_accel_expires = h;
3616
3617 #if (NGX_HTTP_CACHE)
3618 {
3619 u_char *p;
3620 size_t len;
3621 ngx_int_t n;
3622
3623 if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES) {
3624 return NGX_OK;
3625 }
3626
3627 if (r->cache == NULL) {
3628 return NGX_OK;
3629 }
3630
3631 len = h->value.len;
3632 p = h->value.data;
3633
3634 if (p[0] != '@') {
3635 n = ngx_atoi(p, len);
3636
3637 switch (n) {
3638 case 0:
3639 u->cacheable = 0;
3640 /* fall through */
3641
3642 case NGX_ERROR:
3643 return NGX_OK;
3644
3645 default:
3646 r->cache->valid_sec = ngx_time() + n;
3647 return NGX_OK;
3648 }
3649 }
3650
3651 p++;
3652 len--;
3653
3654 n = ngx_atoi(p, len);
3655
3656 if (n != NGX_ERROR) {
3657 r->cache->valid_sec = n;
3658 }
3659 }
3660 #endif
3661
3662 return NGX_OK;
3663 }
3664
3665
3666 static ngx_int_t
3667 ngx_http_upstream_process_limit_rate(ngx_http_request_t *r, ngx_table_elt_t *h,
3668 ngx_uint_t offset)
3669 {
3670 ngx_int_t n;
3671 ngx_http_upstream_t *u;
3672
3673 u = r->upstream;
3674 u->headers_in.x_accel_limit_rate = h;
3675
3676 if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE) {
3677 return NGX_OK;
3678 }
3679
3680 n = ngx_atoi(h->value.data, h->value.len);
3681
3682 if (n != NGX_ERROR) {
3683 r->limit_rate = (size_t) n;
3684 }
3685
3686 return NGX_OK;
3687 }
3688
3689
3690 static ngx_int_t
3691 ngx_http_upstream_process_buffering(ngx_http_request_t *r, ngx_table_elt_t *h,
3692 ngx_uint_t offset)
3693 {
3694 u_char c0, c1, c2;
3695 ngx_http_upstream_t *u;
3696
3697 u = r->upstream;
3698
3699 if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING) {
3700 return NGX_OK;
3701 }
3702
3703 if (u->conf->change_buffering) {
3704
3705 if (h->value.len == 2) {
3706 c0 = ngx_tolower(h->value.data[0]);
3707 c1 = ngx_tolower(h->value.data[1]);
3708
3709 if (c0 == 'n' && c1 == 'o') {
3710 u->buffering = 0;
3711 }
3712
3713 } else if (h->value.len == 3) {
3714 c0 = ngx_tolower(h->value.data[0]);
3715 c1 = ngx_tolower(h->value.data[1]);
3716 c2 = ngx_tolower(h->value.data[2]);
3717
3718 if (c0 == 'y' && c1 == 'e' && c2 == 's') {
3719 u->buffering = 1;
3720 }
3721 }
3722 }
3723
3724 return NGX_OK;
3725 }
3726
3727
3728 static ngx_int_t
3729 ngx_http_upstream_process_charset(ngx_http_request_t *r, ngx_table_elt_t *h,
3730 ngx_uint_t offset)
3731 {
3732 if (r->upstream->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_CHARSET) {
3733 return NGX_OK;
3734 }
3735
3736 r->headers_out.override_charset = &h->value;
3737
3738 return NGX_OK;
3739 }
3740
3741
3742 static ngx_int_t
3743 ngx_http_upstream_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
3744 ngx_uint_t offset)
3745 {
3746 r->upstream->headers_in.connection = h;
3747
3748 if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
3749 (u_char *) "close", 5 - 1)
3750 != NULL)
3751 {
3752 r->upstream->headers_in.connection_close = 1;
3753 }
3754
3755 return NGX_OK;
3756 }
3757
3758
3759 static ngx_int_t
3760 ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
3761 ngx_table_elt_t *h, ngx_uint_t offset)
3762 {
3763 r->upstream->headers_in.transfer_encoding = h;
3764
3765 if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
3766 (u_char *) "chunked", 7 - 1)
3767 != NULL)
3768 {
3769 r->upstream->headers_in.chunked = 1;
3770 }
3771
3772 return NGX_OK;
3773 }
3774
3775
3776 static ngx_int_t
3777 ngx_http_upstream_copy_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
3778 ngx_uint_t offset)
3779 {
3780 ngx_table_elt_t *ho, **ph;
3781
3782 ho = ngx_list_push(&r->headers_out.headers);
3783 if (ho == NULL) {
3784 return NGX_ERROR;
3785 }
3786
3787 *ho = *h;
3788
3789 if (offset) {
3790 ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);
3791 *ph = ho;
3792 }
3793
3794 return NGX_OK;
3795 }
3796
3797
3798 static ngx_int_t
3799 ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
3800 ngx_table_elt_t *h, ngx_uint_t offset)
3801 {
3802 ngx_array_t *pa;
3803 ngx_table_elt_t *ho, **ph;
3804
3805 pa = (ngx_array_t *) ((char *) &r->headers_out + offset);
3806
3807 if (pa->elts == NULL) {
3808 if (ngx_array_init(pa, r->pool, 2, sizeof(ngx_table_elt_t *)) != NGX_OK)
3809 {
3810 return NGX_ERROR;
3811 }
3812 }
3813
3814 ph = ngx_array_push(pa);
3815 if (ph == NULL) {
3816 return NGX_ERROR;
3817 }
3818
3819 ho = ngx_list_push(&r->headers_out.headers);
3820 if (ho == NULL) {
3821 return NGX_ERROR;
3822 }
3823
3824 *ho = *h;
3825 *ph = ho;
3826
3827 return NGX_OK;
3828 }
3829
3830
3831 static ngx_int_t
3832 ngx_http_upstream_copy_content_type(ngx_http_request_t *r, ngx_table_elt_t *h,
3833 ngx_uint_t offset)
3834 {
3835 u_char *p, *last;
3836
3837 r->headers_out.content_type_len = h->value.len;
3838 r->headers_out.content_type = h->value;
3839 r->headers_out.content_type_lowcase = NULL;
3840
3841 for (p = h->value.data; *p; p++) {
3842
3843 if (*p != ';') {
3844 continue;
3845 }
3846
3847 last = p;
3848
3849 while (*++p == ' ') { /* void */ }
3850
3851 if (*p == '\0') {
3852 return NGX_OK;
3853 }
3854
3855 if (ngx_strncasecmp(p, (u_char *) "charset=", 8) != 0) {
3856 continue;
3857 }
3858
3859 p += 8;
3860
3861 r->headers_out.content_type_len = last - h->value.data;
3862
3863 if (*p == '"') {
3864 p++;
3865 }
3866
3867 last = h->value.data + h->value.len;
3868
3869 if (*(last - 1) == '"') {
3870 last--;
3871 }
3872
3873 r->headers_out.charset.len = last - p;
3874 r->headers_out.charset.data = p;
3875
3876 return NGX_OK;
3877 }
3878
3879 return NGX_OK;
3880 }
3881
3882
3883 static ngx_int_t
3884 ngx_http_upstream_copy_last_modified(ngx_http_request_t *r, ngx_table_elt_t *h,
3885 ngx_uint_t offset)
3886 {
3887 ngx_table_elt_t *ho;
3888
3889 ho = ngx_list_push(&r->headers_out.headers);
3890 if (ho == NULL) {
3891 return NGX_ERROR;
3892 }
3893
3894 *ho = *h;
3895
3896 r->headers_out.last_modified = ho;
3897
3898 #if (NGX_HTTP_CACHE)
3899
3900 if (r->upstream->cacheable) {
3901 r->headers_out.last_modified_time = ngx_http_parse_time(h->value.data,
3902 h->value.len);
3903 }
3904
3905 #endif
3906
3907 return NGX_OK;
3908 }
3909
3910
3911 static ngx_int_t
3912 ngx_http_upstream_rewrite_location(ngx_http_request_t *r, ngx_table_elt_t *h,
3913 ngx_uint_t offset)
3914 {
3915 ngx_int_t rc;
3916 ngx_table_elt_t *ho;
3917
3918 ho = ngx_list_push(&r->headers_out.headers);
3919 if (ho == NULL) {
3920 return NGX_ERROR;
3921 }
3922
3923 *ho = *h;
3924
3925 if (r->upstream->rewrite_redirect) {
3926 rc = r->upstream->rewrite_redirect(r, ho, 0);
3927
3928 if (rc == NGX_DECLINED) {
3929 return NGX_OK;
3930 }
3931
3932 if (rc == NGX_OK) {
3933 r->headers_out.location = ho;
3934
3935 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3936 "rewritten location: \"%V\"", &ho->value);
3937 }
3938
3939 return rc;
3940 }
3941
3942 if (ho->value.data[0] != '/') {
3943 r->headers_out.location = ho;
3944 }
3945
3946 /*
3947 * we do not set r->headers_out.location here to avoid the handling
3948 * the local redirects without a host name by ngx_http_header_filter()
3949 */
3950
3951 return NGX_OK;
3952 }
3953
3954
3955 static ngx_int_t
3956 ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r, ngx_table_elt_t *h,
3957 ngx_uint_t offset)
3958 {
3959 u_char *p;
3960 ngx_int_t rc;
3961 ngx_table_elt_t *ho;
3962
3963 ho = ngx_list_push(&r->headers_out.headers);
3964 if (ho == NULL) {
3965 return NGX_ERROR;
3966 }
3967
3968 *ho = *h;
3969
3970 if (r->upstream->rewrite_redirect) {
3971
3972 p = ngx_strcasestrn(ho->value.data, "url=", 4 - 1);
3973
3974 if (p) {
3975 rc = r->upstream->rewrite_redirect(r, ho, p + 4 - ho->value.data);
3976
3977 } else {
3978 return NGX_OK;
3979 }
3980
3981 if (rc == NGX_DECLINED) {
3982 return NGX_OK;
3983 }
3984
3985 if (rc == NGX_OK) {
3986 r->headers_out.refresh = ho;
3987
3988 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
3989 "rewritten refresh: \"%V\"", &ho->value);
3990 }
3991
3992 return rc;
3993 }
3994
3995 r->headers_out.refresh = ho;
3996
3997 return NGX_OK;
3998 }
3999
4000
4001 static ngx_int_t
4002 ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
4003 ngx_uint_t offset)
4004 {
4005 ngx_int_t rc;
4006 ngx_table_elt_t *ho;
4007
4008 ho = ngx_list_push(&r->headers_out.headers);
4009 if (ho == NULL) {
4010 return NGX_ERROR;
4011 }
4012
4013 *ho = *h;
4014
4015 if (r->upstream->rewrite_cookie) {
4016 rc = r->upstream->rewrite_cookie(r, ho);
4017
4018 if (rc == NGX_DECLINED) {
4019 return NGX_OK;
4020 }
4021
4022 #if (NGX_DEBUG)
4023 if (rc == NGX_OK) {
4024 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
4025 "rewritten cookie: \"%V\"", &ho->value);
4026 }
4027 #endif
4028
4029 return rc;
4030 }
4031
4032 return NGX_OK;
4033 }
4034
4035
4036 static ngx_int_t
4037 ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
4038 ngx_table_elt_t *h, ngx_uint_t offset)
4039 {
4040 ngx_table_elt_t *ho;
4041
4042 #if (NGX_HTTP_CACHE)
4043
4044 if (r->cached) {
4045 r->allow_ranges = 1;
4046 return NGX_OK;
4047
4048 }
4049
4050 #endif
4051
4052 ho = ngx_list_push(&r->headers_out.headers);
4053 if (ho == NULL) {
4054 return NGX_ERROR;
4055 }
4056
4057 *ho = *h;
4058
4059 r->headers_out.accept_ranges = ho;
4060
4061 return NGX_OK;
4062 }
4063
4064
4065 #if (NGX_HTTP_GZIP)
4066
4067 static ngx_int_t
4068 ngx_http_upstream_copy_content_encoding(ngx_http_request_t *r,
4069 ngx_table_elt_t *h, ngx_uint_t offset)
4070 {
4071 ngx_table_elt_t *ho;
4072
4073 ho = ngx_list_push(&r->headers_out.headers);
4074 if (ho == NULL) {
4075 return NGX_ERROR;
4076 }
4077
4078 *ho = *h;
4079
4080 r->headers_out.content_encoding = ho;
4081
4082 return NGX_OK;
4083 }
4084
4085 #endif
4086
4087
4088 static ngx_int_t
4089 ngx_http_upstream_add_variables(ngx_conf_t *cf)
4090 {
4091 ngx_http_variable_t *var, *v;
4092
4093 for (v = ngx_http_upstream_vars; v->name.len; v++) {
4094 var = ngx_http_add_variable(cf, &v->name, v->flags);
4095 if (var == NULL) {
4096 return NGX_ERROR;
4097 }
4098
4099 var->get_handler = v->get_handler;
4100 var->data = v->data;
4101 }
4102
4103 return NGX_OK;
4104 }
4105
4106
4107 static ngx_int_t
4108 ngx_http_upstream_addr_variable(ngx_http_request_t *r,
4109 ngx_http_variable_value_t *v, uintptr_t data)
4110 {
4111 u_char *p;
4112 size_t len;
4113 ngx_uint_t i;
4114 ngx_http_upstream_state_t *state;
4115
4116 v->valid = 1;
4117 v->no_cacheable = 0;
4118 v->not_found = 0;
4119
4120 if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
4121 v->not_found = 1;
4122 return NGX_OK;
4123 }
4124
4125 len = 0;
4126 state = r->upstream_states->elts;
4127
4128 for (i = 0; i < r->upstream_states->nelts; i++) {
4129 if (state[i].peer) {
4130 len += state[i].peer->len + 2;
4131
4132 } else {
4133 len += 3;
4134 }
4135 }
4136
4137 p = ngx_pnalloc(r->pool, len);
4138 if (p == NULL) {
4139 return NGX_ERROR;
4140 }
4141
4142 v->data = p;
4143
4144 i = 0;
4145
4146 for ( ;; ) {
4147 if (state[i].peer) {
4148 p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
4149 }
4150
4151 if (++i == r->upstream_states->nelts) {
4152 break;
4153 }
4154
4155 if (state[i].peer) {
4156 *p++ = ',';
4157 *p++ = ' ';
4158
4159 } else {
4160 *p++ = ' ';
4161 *p++ = ':';
4162 *p++ = ' ';
4163
4164 if (++i == r->upstream_states->nelts) {
4165 break;
4166 }
4167
4168 continue;
4169 }
4170 }
4171
4172 v->len = p - v->data;
4173
4174 return NGX_OK;
4175 }
4176
4177
4178 static ngx_int_t
4179 ngx_http_upstream_status_variable(ngx_http_request_t *r,
4180 ngx_http_variable_value_t *v, uintptr_t data)
4181 {
4182 u_char *p;
4183 size_t len;
4184 ngx_uint_t i;
4185 ngx_http_upstream_state_t *state;
4186
4187 v->valid = 1;
4188 v->no_cacheable = 0;
4189 v->not_found = 0;
4190
4191 if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
4192 v->not_found = 1;
4193 return NGX_OK;
4194 }
4195
4196 len = r->upstream_states->nelts * (3 + 2);
4197
4198 p = ngx_pnalloc(r->pool, len);
4199 if (p == NULL) {
4200 return NGX_ERROR;
4201 }
4202
4203 v->data = p;
4204
4205 i = 0;
4206 state = r->upstream_states->elts;
4207
4208 for ( ;; ) {
4209 if (state[i].status) {
4210 p = ngx_sprintf(p, "%ui", state[i].status);
4211
4212 } else {
4213 *p++ = '-';
4214 }
4215
4216 if (++i == r->upstream_states->nelts) {
4217 break;
4218 }
4219
4220 if (state[i].peer) {
4221 *p++ = ',';
4222 *p++ = ' ';
4223
4224 } else {
4225 *p++ = ' ';
4226 *p++ = ':';
4227 *p++ = ' ';
4228
4229 if (++i == r->upstream_states->nelts) {
4230 break;
4231 }
4232
4233 continue;
4234 }
4235 }
4236
4237 v->len = p - v->data;
4238
4239 return NGX_OK;
4240 }
4241
4242
4243 static ngx_int_t
4244 ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
4245 ngx_http_variable_value_t *v, uintptr_t data)
4246 {
4247 u_char *p;
4248 size_t len;
4249 ngx_uint_t i;
4250 ngx_msec_int_t ms;
4251 ngx_http_upstream_state_t *state;
4252
4253 v->valid = 1;
4254 v->no_cacheable = 0;
4255 v->not_found = 0;
4256
4257 if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
4258 v->not_found = 1;
4259 return NGX_OK;
4260 }
4261
4262 len = r->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);
4263
4264 p = ngx_pnalloc(r->pool, len);
4265 if (p == NULL) {
4266 return NGX_ERROR;
4267 }
4268
4269 v->data = p;
4270
4271 i = 0;
4272 state = r->upstream_states->elts;
4273
4274 for ( ;; ) {
4275 if (state[i].status) {
4276 ms = (ngx_msec_int_t)
4277 (state[i].response_sec * 1000 + state[i].response_msec);
4278 ms = ngx_max(ms, 0);
4279 p = ngx_sprintf(p, "%d.%03d", ms / 1000, ms % 1000);
4280
4281 } else {
4282 *p++ = '-';
4283 }
4284
4285 if (++i == r->upstream_states->nelts) {
4286 break;
4287 }
4288
4289 if (state[i].peer) {
4290 *p++ = ',';
4291 *p++ = ' ';
4292
4293 } else {
4294 *p++ = ' ';
4295 *p++ = ':';
4296 *p++ = ' ';
4297
4298 if (++i == r->upstream_states->nelts) {
4299 break;
4300 }
4301
4302 continue;
4303 }
4304 }
4305
4306 v->len = p - v->data;
4307
4308 return NGX_OK;
4309 }
4310
4311
4312 static ngx_int_t
4313 ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
4314 ngx_http_variable_value_t *v, uintptr_t data)
4315 {
4316 u_char *p;
4317 size_t len;
4318 ngx_uint_t i;
4319 ngx_http_upstream_state_t *state;
4320
4321 v->valid = 1;
4322 v->no_cacheable = 0;
4323 v->not_found = 0;
4324
4325 if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
4326 v->not_found = 1;
4327 return NGX_OK;
4328 }
4329
4330 len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);
4331
4332 p = ngx_pnalloc(r->pool, len);
4333 if (p == NULL) {
4334 return NGX_ERROR;
4335 }
4336
4337 v->data = p;
4338
4339 i = 0;
4340 state = r->upstream_states->elts;
4341
4342 for ( ;; ) {
4343 p = ngx_sprintf(p, "%O", state[i].response_length);
4344
4345 if (++i == r->upstream_states->nelts) {
4346 break;
4347 }
4348
4349 if (state[i].peer) {
4350 *p++ = ',';
4351 *p++ = ' ';
4352
4353 } else {
4354 *p++ = ' ';
4355 *p++ = ':';
4356 *p++ = ' ';
4357
4358 if (++i == r->upstream_states->nelts) {
4359 break;
4360 }
4361
4362 continue;
4363 }
4364 }
4365
4366 v->len = p - v->data;
4367
4368 return NGX_OK;
4369 }
4370
4371
4372 ngx_int_t
4373 ngx_http_upstream_header_variable(ngx_http_request_t *r,
4374 ngx_http_variable_value_t *v, uintptr_t data)
4375 {
4376 if (r->upstream == NULL) {
4377 v->not_found = 1;
4378 return NGX_OK;
4379 }
4380
4381 return ngx_http_variable_unknown_header(v, (ngx_str_t *) data,
4382 &r->upstream->headers_in.headers.part,
4383 sizeof("upstream_http_") - 1);
4384 }
4385
4386
4387 #if (NGX_HTTP_CACHE)
4388
4389 ngx_int_t
4390 ngx_http_upstream_cache_status(ngx_http_request_t *r,
4391 ngx_http_variable_value_t *v, uintptr_t data)
4392 {
4393 ngx_uint_t n;
4394
4395 if (r->upstream == NULL || r->upstream->cache_status == 0) {
4396 v->not_found = 1;
4397 return NGX_OK;
4398 }
4399
4400 n = r->upstream->cache_status - 1;
4401
4402 v->valid = 1;
4403 v->no_cacheable = 0;
4404 v->not_found = 0;
4405 v->len = ngx_http_cache_status[n].len;
4406 v->data = ngx_http_cache_status[n].data;
4407
4408 return NGX_OK;
4409 }
4410
4411 #endif
4412
4413
4414 static char *
4415 ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
4416 {
4417 char *rv;
4418 void *mconf;
4419 ngx_str_t *value;
4420 ngx_url_t u;
4421 ngx_uint_t m;
4422 ngx_conf_t pcf;
4423 ngx_http_module_t *module;
4424 ngx_http_conf_ctx_t *ctx, *http_ctx;
4425 ngx_http_upstream_srv_conf_t *uscf;
4426
4427 ngx_memzero(&u, sizeof(ngx_url_t));
4428
4429 value = cf->args->elts;
4430 u.host = value[1];
4431 u.no_resolve = 1;
4432 u.no_port = 1;
4433
4434 uscf = ngx_http_upstream_add(cf, &u, NGX_HTTP_UPSTREAM_CREATE
4435 |NGX_HTTP_UPSTREAM_WEIGHT
4436 |NGX_HTTP_UPSTREAM_MAX_FAILS
4437 |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
4438 |NGX_HTTP_UPSTREAM_DOWN
4439 |NGX_HTTP_UPSTREAM_BACKUP);
4440 if (uscf == NULL) {
4441 return NGX_CONF_ERROR;
4442 }
4443
4444
4445 ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
4446 if (ctx == NULL) {
4447 return NGX_CONF_ERROR;
4448 }
4449
4450 http_ctx = cf->ctx;
4451 ctx->main_conf = http_ctx->main_conf;
4452
4453 /* the upstream{}'s srv_conf */
4454
4455 ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
4456 if (ctx->srv_conf == NULL) {
4457 return NGX_CONF_ERROR;
4458 }
4459
4460 ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;
4461
4462 uscf->srv_conf = ctx->srv_conf;
4463
4464
4465 /* the upstream{}'s loc_conf */
4466
4467 ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
4468 if (ctx->loc_conf == NULL) {
4469 return NGX_CONF_ERROR;
4470 }
4471
4472 for (m = 0; ngx_modules[m]; m++) {
4473 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
4474 continue;
4475 }
4476
4477 module = ngx_modules[m]->ctx;
4478
4479 if (module->create_srv_conf) {
4480 mconf = module->create_srv_conf(cf);
4481 if (mconf == NULL) {
4482 return NGX_CONF_ERROR;
4483 }
4484
4485 ctx->srv_conf[ngx_modules[m]->ctx_index] = mconf;
4486 }
4487
4488 if (module->create_loc_conf) {
4489 mconf = module->create_loc_conf(cf);
4490 if (mconf == NULL) {
4491 return NGX_CONF_ERROR;
4492 }
4493
4494 ctx->loc_conf[ngx_modules[m]->ctx_index] = mconf;
4495 }
4496 }
4497
4498
4499 /* parse inside upstream{} */
4500
4501 pcf = *cf;
4502 cf->ctx = ctx;
4503 cf->cmd_type = NGX_HTTP_UPS_CONF;
4504
4505 rv = ngx_conf_parse(cf, NULL);
4506
4507 *cf = pcf;
4508
4509 if (rv != NGX_CONF_OK) {
4510 return rv;
4511 }
4512
4513 if (uscf->servers == NULL) {
4514 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4515 "no servers are inside upstream");
4516 return NGX_CONF_ERROR;
4517 }
4518
4519 return rv;
4520 }
4521
4522
4523 static char *
4524 ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
4525 {
4526 ngx_http_upstream_srv_conf_t *uscf = conf;
4527
4528 time_t fail_timeout;
4529 ngx_str_t *value, s;
4530 ngx_url_t u;
4531 ngx_int_t weight, max_fails;
4532 ngx_uint_t i;
4533 ngx_http_upstream_server_t *us;
4534
4535 if (uscf->servers == NULL) {
4536 uscf->servers = ngx_array_create(cf->pool, 4,
4537 sizeof(ngx_http_upstream_server_t));
4538 if (uscf->servers == NULL) {
4539 return NGX_CONF_ERROR;
4540 }
4541 }
4542
4543 us = ngx_array_push(uscf->servers);
4544 if (us == NULL) {
4545 return NGX_CONF_ERROR;
4546 }
4547
4548 ngx_memzero(us, sizeof(ngx_http_upstream_server_t));
4549
4550 value = cf->args->elts;
4551
4552 ngx_memzero(&u, sizeof(ngx_url_t));
4553
4554 u.url = value[1];
4555 u.default_port = 80;
4556
4557 if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
4558 if (u.err) {
4559 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4560 "%s in upstream \"%V\"", u.err, &u.url);
4561 }
4562
4563 return NGX_CONF_ERROR;
4564 }
4565
4566 weight = 1;
4567 max_fails = 1;
4568 fail_timeout = 10;
4569
4570 for (i = 2; i < cf->args->nelts; i++) {
4571
4572 if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {
4573
4574 if (!(uscf->flags & NGX_HTTP_UPSTREAM_WEIGHT)) {
4575 goto invalid;
4576 }
4577
4578 weight = ngx_atoi(&value[i].data[7], value[i].len - 7);
4579
4580 if (weight == NGX_ERROR || weight == 0) {
4581 goto invalid;
4582 }
4583
4584 continue;
4585 }
4586
4587 if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {
4588
4589 if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_FAILS)) {
4590 goto invalid;
4591 }
4592
4593 max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);
4594
4595 if (max_fails == NGX_ERROR) {
4596 goto invalid;
4597 }
4598
4599 continue;
4600 }
4601
4602 if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {
4603
4604 if (!(uscf->flags & NGX_HTTP_UPSTREAM_FAIL_TIMEOUT)) {
4605 goto invalid;
4606 }
4607
4608 s.len = value[i].len - 13;
4609 s.data = &value[i].data[13];
4610
4611 fail_timeout = ngx_parse_time(&s, 1);
4612
4613 if (fail_timeout == (time_t) NGX_ERROR) {
4614 goto invalid;
4615 }
4616
4617 continue;
4618 }
4619
4620 if (ngx_strncmp(value[i].data, "backup", 6) == 0) {
4621
4622 if (!(uscf->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
4623 goto invalid;
4624 }
4625
4626 us->backup = 1;
4627
4628 continue;
4629 }
4630
4631 if (ngx_strncmp(value[i].data, "down", 4) == 0) {
4632
4633 if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
4634 goto invalid;
4635 }
4636
4637 us->down = 1;
4638
4639 continue;
4640 }
4641
4642 goto invalid;
4643 }
4644
4645 us->addrs = u.addrs;
4646 us->naddrs = u.naddrs;
4647 us->weight = weight;
4648 us->max_fails = max_fails;
4649 us->fail_timeout = fail_timeout;
4650
4651 return NGX_CONF_OK;
4652
4653 invalid:
4654
4655 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4656 "invalid parameter \"%V\"", &value[i]);
4657
4658 return NGX_CONF_ERROR;
4659 }
4660
4661
4662 ngx_http_upstream_srv_conf_t *
4663 ngx_http_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
4664 {
4665 ngx_uint_t i;
4666 ngx_http_upstream_server_t *us;
4667 ngx_http_upstream_srv_conf_t *uscf, **uscfp;
4668 ngx_http_upstream_main_conf_t *umcf;
4669
4670 if (!(flags & NGX_HTTP_UPSTREAM_CREATE)) {
4671
4672 if (ngx_parse_url(cf->pool, u) != NGX_OK) {
4673 if (u->err) {
4674 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4675 "%s in upstream \"%V\"", u->err, &u->url);
4676 }
4677
4678 return NULL;
4679 }
4680 }
4681
4682 umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);
4683
4684 uscfp = umcf->upstreams.elts;
4685
4686 for (i = 0; i < umcf->upstreams.nelts; i++) {
4687
4688 if (uscfp[i]->host.len != u->host.len
4689 || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
4690 != 0)
4691 {
4692 continue;
4693 }
4694
4695 if ((flags & NGX_HTTP_UPSTREAM_CREATE)
4696 && (uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE))
4697 {
4698 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4699 "duplicate upstream \"%V\"", &u->host);
4700 return NULL;
4701 }
4702
4703 if ((uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE) && !u->no_port) {
4704 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
4705 "upstream \"%V\" may not have port %d",
4706 &u->host, u->port);
4707 return NULL;
4708 }
4709
4710 if ((flags & NGX_HTTP_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
4711 ngx_log_error(NGX_LOG_WARN, cf->log, 0,
4712 "upstream \"%V\" may not have port %d in %s:%ui",
4713 &u->host, uscfp[i]->port,
4714 uscfp[i]->file_name, uscfp[i]->line);
4715 return NULL;
4716 }
4717
4718 if (uscfp[i]->port && u->port
4719 && uscfp[i]->port != u->port)
4720 {
4721 continue;
4722 }
4723
4724 if (uscfp[i]->default_port && u->default_port
4725 && uscfp[i]->default_port != u->default_port)
4726 {
4727 continue;
4728 }
4729
4730 if (flags & NGX_HTTP_UPSTREAM_CREATE) {
4731 uscfp[i]->flags = flags;
4732 }
4733
4734 return uscfp[i];
4735 }
4736
4737 uscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
4738 if (uscf == NULL) {
4739 return NULL;
4740 }
4741
4742 uscf->flags = flags;
4743 uscf->host = u->host;
4744 uscf->file_name = cf->conf_file->file.name.data;
4745 uscf->line = cf->conf_file->line;
4746 uscf->port = u->port;
4747 uscf->default_port = u->default_port;
4748 uscf->no_port = u->no_port;
4749
4750 if (u->naddrs == 1) {
4751 uscf->servers = ngx_array_create(cf->pool, 1,
4752 sizeof(ngx_http_upstream_server_t));
4753 if (uscf->servers == NULL) {
4754 return NULL;
4755 }
4756
4757 us = ngx_array_push(uscf->servers);
4758 if (us == NULL) {
4759 return NULL;
4760 }
4761
4762 ngx_memzero(us, sizeof(ngx_http_upstream_server_t));
4763
4764 us->addrs = u->addrs;
4765 us->naddrs = 1;
4766 }
4767
4768 uscfp = ngx_array_push(&umcf->upstreams);
4769 if (uscfp == NULL) {
4770 return NULL;
4771 }
4772
4773 *uscfp = uscf;
4774
4775 return uscf;
4776 }
4777
4778
4779 char *
4780 ngx_http_upstream_bind_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
4781 void *conf)
4782 {
4783 char *p = conf;
4784
4785 ngx_int_t rc;
4786 ngx_str_t *value;
4787 ngx_http_complex_value_t cv;
4788 ngx_http_upstream_local_t **plocal, *local;
4789 ngx_http_compile_complex_value_t ccv;
4790
4791 plocal = (ngx_http_upstream_local_t **) (p + cmd->offset);
4792
4793 if (*plocal != NGX_CONF_UNSET_PTR) {
4794 return "is duplicate";
4795 }
4796
4797 value = cf->args->elts;
4798
4799 if (ngx_strcmp(value[1].data, "off") == 0) {
4800 *plocal = NULL;
4801 return NGX_CONF_OK;
4802 }
4803
4804 ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
4805
4806 ccv.cf = cf;
4807 ccv.value = &value[1];
4808 ccv.complex_value = &cv;
4809
4810 if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
4811 return NGX_CONF_ERROR;
4812 }
4813
4814 local = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_local_t));
4815 if (local == NULL) {
4816 return NGX_CONF_ERROR;
4817 }
4818
4819 *plocal = local;
4820
4821 if (cv.lengths) {
4822 local->value = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
4823 if (local->value == NULL) {
4824 return NGX_CONF_ERROR;
4825 }
4826
4827 *local->value = cv;
4828
4829 return NGX_CONF_OK;
4830 }
4831
4832 local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
4833 if (local->addr == NULL) {
4834 return NGX_CONF_ERROR;
4835 }
4836
4837 rc = ngx_parse_addr(cf->pool, local->addr, value[1].data, value[1].len);
4838
4839 switch (rc) {
4840 case NGX_OK:
4841 local->addr->name = value[1];
4842 return NGX_CONF_OK;
4843
4844 case NGX_DECLINED:
4845 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4846 "invalid address \"%V\"", &value[1]);
4847 /* fall through */
4848
4849 default:
4850 return NGX_CONF_ERROR;
4851 }
4852 }
4853
4854
4855 static ngx_addr_t *
4856 ngx_http_upstream_get_local(ngx_http_request_t *r,
4857 ngx_http_upstream_local_t *local)
4858 {
4859 ngx_int_t rc;
4860 ngx_str_t val;
4861 ngx_addr_t *addr;
4862
4863 if (local == NULL) {
4864 return NULL;
4865 }
4866
4867 if (local->value == NULL) {
4868 return local->addr;
4869 }
4870
4871 if (ngx_http_complex_value(r, local->value, &val) != NGX_OK) {
4872 return NULL;
4873 }
4874
4875 if (val.len == 0) {
4876 return NULL;
4877 }
4878
4879 addr = ngx_palloc(r->pool, sizeof(ngx_addr_t));
4880 if (addr == NULL) {
4881 return NULL;
4882 }
4883
4884 rc = ngx_parse_addr(r->pool, addr, val.data, val.len);
4885
4886 switch (rc) {
4887 case NGX_OK:
4888 addr->name = val;
4889 return addr;
4890
4891 case NGX_DECLINED:
4892 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
4893 "invalid local address \"%V\"", &val);
4894 /* fall through */
4895
4896 default:
4897 return NULL;
4898 }
4899 }
4900
4901
4902 char *
4903 ngx_http_upstream_param_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
4904 void *conf)
4905 {
4906 char *p = conf;
4907
4908 ngx_str_t *value;
4909 ngx_array_t **a;
4910 ngx_http_upstream_param_t *param;
4911
4912 a = (ngx_array_t **) (p + cmd->offset);
4913
4914 if (*a == NULL) {
4915 *a = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_param_t));
4916 if (*a == NULL) {
4917 return NGX_CONF_ERROR;
4918 }
4919 }
4920
4921 param = ngx_array_push(*a);
4922 if (param == NULL) {
4923 return NGX_CONF_ERROR;
4924 }
4925
4926 value = cf->args->elts;
4927
4928 param->key = value[1];
4929 param->value = value[2];
4930 param->skip_empty = 0;
4931
4932 if (cf->args->nelts == 4) {
4933 if (ngx_strcmp(value[3].data, "if_not_empty") != 0) {
4934 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
4935 "invalid parameter \"%V\"", &value[3]);
4936 return NGX_CONF_ERROR;
4937 }
4938
4939 param->skip_empty = 1;
4940 }
4941
4942 return NGX_CONF_OK;
4943 }
4944
4945
4946 ngx_int_t
4947 ngx_http_upstream_hide_headers_hash(ngx_conf_t *cf,
4948 ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev,
4949 ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
4950 {
4951 ngx_str_t *h;
4952 ngx_uint_t i, j;
4953 ngx_array_t hide_headers;
4954 ngx_hash_key_t *hk;
4955
4956 if (conf->hide_headers == NGX_CONF_UNSET_PTR
4957 && conf->pass_headers == NGX_CONF_UNSET_PTR)
4958 {
4959 conf->hide_headers = prev->hide_headers;
4960 conf->pass_headers = prev->pass_headers;
4961
4962 conf->hide_headers_hash = prev->hide_headers_hash;
4963
4964 if (conf->hide_headers_hash.buckets
4965 #if (NGX_HTTP_CACHE)
4966 && ((conf->cache == NULL) == (prev->cache == NULL))
4967 #endif
4968 )
4969 {
4970 return NGX_OK;
4971 }
4972
4973 } else {
4974 if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
4975 conf->hide_headers = prev->hide_headers;
4976 }
4977
4978 if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
4979 conf->pass_headers = prev->pass_headers;
4980 }
4981 }
4982
4983 if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
4984 != NGX_OK)
4985 {
4986 return NGX_ERROR;
4987 }
4988
4989 for (h = default_hide_headers; h->len; h++) {
4990 hk = ngx_array_push(&hide_headers);
4991 if (hk == NULL) {
4992 return NGX_ERROR;
4993 }
4994
4995 hk->key = *h;
4996 hk->key_hash = ngx_hash_key_lc(h->data, h->len);
4997 hk->value = (void *) 1;
4998 }
4999
5000 if (conf->hide_headers != NGX_CONF_UNSET_PTR) {
5001
5002 h = conf->hide_headers->elts;
5003
5004 for (i = 0; i < conf->hide_headers->nelts; i++) {
5005
5006 hk = hide_headers.elts;
5007
5008 for (j = 0; j < hide_headers.nelts; j++) {
5009 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
5010 goto exist;
5011 }
5012 }
5013
5014 hk = ngx_array_push(&hide_headers);
5015 if (hk == NULL) {
5016 return NGX_ERROR;
5017 }
5018
5019 hk->key = h[i];
5020 hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
5021 hk->value = (void *) 1;
5022
5023 exist:
5024
5025 continue;
5026 }
5027 }
5028
5029 if (conf->pass_headers != NGX_CONF_UNSET_PTR) {
5030
5031 h = conf->pass_headers->elts;
5032 hk = hide_headers.elts;
5033
5034 for (i = 0; i < conf->pass_headers->nelts; i++) {
5035 for (j = 0; j < hide_headers.nelts; j++) {
5036
5037 if (hk[j].key.data == NULL) {
5038 continue;
5039 }
5040
5041 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
5042 hk[j].key.data = NULL;
5043 break;
5044 }
5045 }
5046 }
5047 }
5048
5049 hash->hash = &conf->hide_headers_hash;
5050 hash->key = ngx_hash_key_lc;
5051 hash->pool = cf->pool;
5052 hash->temp_pool = NULL;
5053
5054 return ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts);
5055 }
5056
5057
5058 static void *
5059 ngx_http_upstream_create_main_conf(ngx_conf_t *cf)
5060 {
5061 ngx_http_upstream_main_conf_t *umcf;
5062
5063 umcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_main_conf_t));
5064 if (umcf == NULL) {
5065 return NULL;
5066 }
5067
5068 if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
5069 sizeof(ngx_http_upstream_srv_conf_t *))
5070 != NGX_OK)
5071 {
5072 return NULL;
5073 }
5074
5075 return umcf;
5076 }
5077
5078
5079 static char *
5080 ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
5081 {
5082 ngx_http_upstream_main_conf_t *umcf = conf;
5083
5084 ngx_uint_t i;
5085 ngx_array_t headers_in;
5086 ngx_hash_key_t *hk;
5087 ngx_hash_init_t hash;
5088 ngx_http_upstream_init_pt init;
5089 ngx_http_upstream_header_t *header;
5090 ngx_http_upstream_srv_conf_t **uscfp;
5091
5092 uscfp = umcf->upstreams.elts;
5093
5094 for (i = 0; i < umcf->upstreams.nelts; i++) {
5095
5096 init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:
5097 ngx_http_upstream_init_round_robin;
5098
5099 if (init(cf, uscfp[i]) != NGX_OK) {
5100 return NGX_CONF_ERROR;
5101 }
5102 }
5103
5104
5105 /* upstream_headers_in_hash */
5106
5107 if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
5108 != NGX_OK)
5109 {
5110 return NGX_CONF_ERROR;
5111 }
5112
5113 for (header = ngx_http_upstream_headers_in; header->name.len; header++) {
5114 hk = ngx_array_push(&headers_in);
5115 if (hk == NULL) {
5116 return NGX_CONF_ERROR;
5117 }
5118
5119 hk->key = header->name;
5120 hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
5121 hk->value = header;
5122 }
5123
5124 hash.hash = &umcf->headers_in_hash;
5125 hash.key = ngx_hash_key_lc;
5126 hash.max_size = 512;
5127 hash.bucket_size = ngx_align(64, ngx_cacheline_size);
5128 hash.name = "upstream_headers_in_hash";
5129 hash.pool = cf->pool;
5130 hash.temp_pool = NULL;
5131
5132 if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
5133 return NGX_CONF_ERROR;
5134 }
5135
5136 return NGX_CONF_OK;
5137 }
Tomato firmware and modifications.