![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_upstream.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http|
Return to ngx_http_upstream.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http |
1.1 misho 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: }