One Level Up Top Level

src/http/ngx_http_upstream.c - nginx-1.7.10

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  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_get(ngx_http_request_t *r,
  17.     ngx_http_upstream_t *u, ngx_http_file_cache_t **cache);
  18. static ngx_int_t ngx_http_upstream_cache_send(ngx_http_request_t *r,
  19.     ngx_http_upstream_t *u);
  20. static ngx_int_t ngx_http_upstream_cache_status(ngx_http_request_t *r,
  21.     ngx_http_variable_value_t *v, uintptr_t data);
  22. static ngx_int_t ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  23.     ngx_http_variable_value_t *v, uintptr_t data);
  24. static ngx_int_t ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  25.     ngx_http_variable_value_t *v, uintptr_t data);
  26. #endif

  28. static void ngx_http_upstream_init_request(ngx_http_request_t *r);
  29. static void ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx);
  30. static void ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r);
  31. static void ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r);
  32. static void ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  33.     ngx_event_t *ev);
  34. static void ngx_http_upstream_connect(ngx_http_request_t *r,
  35.     ngx_http_upstream_t *u);
  36. static ngx_int_t ngx_http_upstream_reinit(ngx_http_request_t *r,
  37.     ngx_http_upstream_t *u);
  38. static void ngx_http_upstream_send_request(ngx_http_request_t *r,
  39.     ngx_http_upstream_t *u);
  40. static void ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  41.     ngx_http_upstream_t *u);
  42. static void ngx_http_upstream_process_header(ngx_http_request_t *r,
  43.     ngx_http_upstream_t *u);
  44. static ngx_int_t ngx_http_upstream_test_next(ngx_http_request_t *r,
  45.     ngx_http_upstream_t *u);
  46. static ngx_int_t ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  47.     ngx_http_upstream_t *u);
  48. static ngx_int_t ngx_http_upstream_test_connect(ngx_connection_t *c);
  49. static ngx_int_t ngx_http_upstream_process_headers(ngx_http_request_t *r,
  50.     ngx_http_upstream_t *u);
  51. static void ngx_http_upstream_process_body_in_memory(ngx_http_request_t *r,
  52.     ngx_http_upstream_t *u);
  53. static void ngx_http_upstream_send_response(ngx_http_request_t *r,
  54.     ngx_http_upstream_t *u);
  55. static void ngx_http_upstream_upgrade(ngx_http_request_t *r,
  56.     ngx_http_upstream_t *u);
  57. static void ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r);
  58. static void ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r);
  59. static void ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  60.     ngx_http_upstream_t *u);
  61. static void ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  62.     ngx_http_upstream_t *u);
  63. static void ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  64.     ngx_uint_t from_upstream, ngx_uint_t do_write);
  65. static void
  66.     ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r);
  67. static void
  68.     ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  69.     ngx_http_upstream_t *u);
  70. static void
  71.     ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  72.     ngx_uint_t do_write);
  73. static ngx_int_t ngx_http_upstream_non_buffered_filter_init(void *data);
  74. static ngx_int_t ngx_http_upstream_non_buffered_filter(void *data,
  75.     ssize_t bytes);
  76. static void ngx_http_upstream_process_downstream(ngx_http_request_t *r);
  77. static void ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  78.     ngx_http_upstream_t *u);
  79. static void ngx_http_upstream_process_request(ngx_http_request_t *r);
  80. static void ngx_http_upstream_store(ngx_http_request_t *r,
  81.     ngx_http_upstream_t *u);
  82. static void ngx_http_upstream_dummy_handler(ngx_http_request_t *r,
  83.     ngx_http_upstream_t *u);
  84. static void ngx_http_upstream_next(ngx_http_request_t *r,
  85.     ngx_http_upstream_t *u, ngx_uint_t ft_type);
  86. static void ngx_http_upstream_cleanup(void *data);
  87. static void ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  88.     ngx_http_upstream_t *u, ngx_int_t rc);

  90. static ngx_int_t ngx_http_upstream_process_header_line(ngx_http_request_t *r,
  91.     ngx_table_elt_t *h, ngx_uint_t offset);
  92. static ngx_int_t ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  93.     ngx_table_elt_t *h, ngx_uint_t offset);
  94. static ngx_int_t ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  95.     ngx_table_elt_t *h, ngx_uint_t offset);
  96. static ngx_int_t ngx_http_upstream_process_set_cookie(ngx_http_request_t *r,
  97.     ngx_table_elt_t *h, ngx_uint_t offset);
  98. static ngx_int_t
  99.     ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  100.     ngx_table_elt_t *h, ngx_uint_t offset);
  101. static ngx_int_t ngx_http_upstream_ignore_header_line(ngx_http_request_t *r,
  102.     ngx_table_elt_t *h, ngx_uint_t offset);
  103. static ngx_int_t ngx_http_upstream_process_expires(ngx_http_request_t *r,
  104.     ngx_table_elt_t *h, ngx_uint_t offset);
  105. static ngx_int_t ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  106.     ngx_table_elt_t *h, ngx_uint_t offset);
  107. static ngx_int_t ngx_http_upstream_process_limit_rate(ngx_http_request_t *r,
  108.     ngx_table_elt_t *h, ngx_uint_t offset);
  109. static ngx_int_t ngx_http_upstream_process_buffering(ngx_http_request_t *r,
  110.     ngx_table_elt_t *h, ngx_uint_t offset);
  111. static ngx_int_t ngx_http_upstream_process_charset(ngx_http_request_t *r,
  112.     ngx_table_elt_t *h, ngx_uint_t offset);
  113. static ngx_int_t ngx_http_upstream_process_connection(ngx_http_request_t *r,
  114.     ngx_table_elt_t *h, ngx_uint_t offset);
  115. static ngx_int_t
  116.     ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  117.     ngx_table_elt_t *h, ngx_uint_t offset);
  118. static ngx_int_t ngx_http_upstream_process_vary(ngx_http_request_t *r,
  119.     ngx_table_elt_t *h, ngx_uint_t offset);
  120. static ngx_int_t ngx_http_upstream_copy_header_line(ngx_http_request_t *r,
  121.     ngx_table_elt_t *h, ngx_uint_t offset);
  122. static ngx_int_t
  123.     ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  124.     ngx_table_elt_t *h, ngx_uint_t offset);
  125. static ngx_int_t ngx_http_upstream_copy_content_type(ngx_http_request_t *r,
  126.     ngx_table_elt_t *h, ngx_uint_t offset);
  127. static ngx_int_t ngx_http_upstream_copy_last_modified(ngx_http_request_t *r,
  128.     ngx_table_elt_t *h, ngx_uint_t offset);
  129. static ngx_int_t ngx_http_upstream_rewrite_location(ngx_http_request_t *r,
  130.     ngx_table_elt_t *h, ngx_uint_t offset);
  131. static ngx_int_t ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r,
  132.     ngx_table_elt_t *h, ngx_uint_t offset);
  133. static ngx_int_t ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r,
  134.     ngx_table_elt_t *h, ngx_uint_t offset);
  135. static ngx_int_t ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  136.     ngx_table_elt_t *h, ngx_uint_t offset);

  138. #if (NGX_HTTP_GZIP)
  139. static ngx_int_t ngx_http_upstream_copy_content_encoding(ngx_http_request_t *r,
  140.     ngx_table_elt_t *h, ngx_uint_t offset);
  141. #endif

  143. static ngx_int_t ngx_http_upstream_add_variables(ngx_conf_t *cf);
  144. static ngx_int_t ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  145.     ngx_http_variable_value_t *v, uintptr_t data);
  146. static ngx_int_t ngx_http_upstream_status_variable(ngx_http_request_t *r,
  147.     ngx_http_variable_value_t *v, uintptr_t data);
  148. static ngx_int_t ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  149.     ngx_http_variable_value_t *v, uintptr_t data);
  150. static ngx_int_t ngx_http_upstream_response_length_variable(
  151.     ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);

  153. static char *ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy);
  154. static char *ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd,
  155.     void *conf);

  157. static ngx_addr_t *ngx_http_upstream_get_local(ngx_http_request_t *r,
  158.     ngx_http_upstream_local_t *local);

  160. static void *ngx_http_upstream_create_main_conf(ngx_conf_t *cf);
  161. static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf);

  163. #if (NGX_HTTP_SSL)
  164. static void ngx_http_upstream_ssl_init_connection(ngx_http_request_t *,
  165.     ngx_http_upstream_t *u, ngx_connection_t *c);
  166. static void ngx_http_upstream_ssl_handshake(ngx_connection_t *c);
  167. static ngx_int_t ngx_http_upstream_ssl_name(ngx_http_request_t *r,
  168.     ngx_http_upstream_t *u, ngx_connection_t *c);
  169. #endif


  172. ‌ngx_http_upstream_header_t  ngx_http_upstream_headers_in[] = {

  174.     { ngx_string("Status"),
  175.                  ngx_http_upstream_process_header_line,
  176.                  offsetof(ngx_http_upstream_headers_in_t, status),
  177.                  ngx_http_upstream_copy_header_line, 0, 0 },

  179.     { ngx_string("Content-Type"),
  180.                  ngx_http_upstream_process_header_line,
  181.                  offsetof(ngx_http_upstream_headers_in_t, content_type),
  182.                  ngx_http_upstream_copy_content_type, 0, 1 },

  184.     { ngx_string("Content-Length"),
  185.                  ngx_http_upstream_process_content_length, 0,
  186.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  188.     { ngx_string("Date"),
  189.                  ngx_http_upstream_process_header_line,
  190.                  offsetof(ngx_http_upstream_headers_in_t, date),
  191.                  ngx_http_upstream_copy_header_line,
  192.                  offsetof(ngx_http_headers_out_t, date), 0 },

  194.     { ngx_string("Last-Modified"),
  195.                  ngx_http_upstream_process_last_modified, 0,
  196.                  ngx_http_upstream_copy_last_modified, 0, 0 },

  198.     { ngx_string("ETag"),
  199.                  ngx_http_upstream_process_header_line,
  200.                  offsetof(ngx_http_upstream_headers_in_t, etag),
  201.                  ngx_http_upstream_copy_header_line,
  202.                  offsetof(ngx_http_headers_out_t, etag), 0 },

  204.     { ngx_string("Server"),
  205.                  ngx_http_upstream_process_header_line,
  206.                  offsetof(ngx_http_upstream_headers_in_t, server),
  207.                  ngx_http_upstream_copy_header_line,
  208.                  offsetof(ngx_http_headers_out_t, server), 0 },

  210.     { ngx_string("WWW-Authenticate"),
  211.                  ngx_http_upstream_process_header_line,
  212.                  offsetof(ngx_http_upstream_headers_in_t, www_authenticate),
  213.                  ngx_http_upstream_copy_header_line, 0, 0 },

  215.     { ngx_string("Location"),
  216.                  ngx_http_upstream_process_header_line,
  217.                  offsetof(ngx_http_upstream_headers_in_t, location),
  218.                  ngx_http_upstream_rewrite_location, 0, 0 },

  220.     { ngx_string("Refresh"),
  221.                  ngx_http_upstream_ignore_header_line, 0,
  222.                  ngx_http_upstream_rewrite_refresh, 0, 0 },

  224.     { ngx_string("Set-Cookie"),
  225.                  ngx_http_upstream_process_set_cookie,
  226.                  offsetof(ngx_http_upstream_headers_in_t, cookies),
  227.                  ngx_http_upstream_rewrite_set_cookie, 0, 1 },

  229.     { ngx_string("Content-Disposition"),
  230.                  ngx_http_upstream_ignore_header_line, 0,
  231.                  ngx_http_upstream_copy_header_line, 0, 1 },

  233.     { ngx_string("Cache-Control"),
  234.                  ngx_http_upstream_process_cache_control, 0,
  235.                  ngx_http_upstream_copy_multi_header_lines,
  236.                  offsetof(ngx_http_headers_out_t, cache_control), 1 },

  238.     { ngx_string("Expires"),
  239.                  ngx_http_upstream_process_expires, 0,
  240.                  ngx_http_upstream_copy_header_line,
  241.                  offsetof(ngx_http_headers_out_t, expires), 1 },

  243.     { ngx_string("Accept-Ranges"),
  244.                  ngx_http_upstream_process_header_line,
  245.                  offsetof(ngx_http_upstream_headers_in_t, accept_ranges),
  246.                  ngx_http_upstream_copy_allow_ranges,
  247.                  offsetof(ngx_http_headers_out_t, accept_ranges), 1 },

  249.     { ngx_string("Connection"),
  250.                  ngx_http_upstream_process_connection, 0,
  251.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  253.     { ngx_string("Keep-Alive"),
  254.                  ngx_http_upstream_ignore_header_line, 0,
  255.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  257.     { ngx_string("Vary"),
  258.                  ngx_http_upstream_process_vary, 0,
  259.                  ngx_http_upstream_copy_header_line, 0, 0 },

  261.     { ngx_string("X-Powered-By"),
  262.                  ngx_http_upstream_ignore_header_line, 0,
  263.                  ngx_http_upstream_copy_header_line, 0, 0 },

  265.     { ngx_string("X-Accel-Expires"),
  266.                  ngx_http_upstream_process_accel_expires, 0,
  267.                  ngx_http_upstream_copy_header_line, 0, 0 },

  269.     { ngx_string("X-Accel-Redirect"),
  270.                  ngx_http_upstream_process_header_line,
  271.                  offsetof(ngx_http_upstream_headers_in_t, x_accel_redirect),
  272.                  ngx_http_upstream_copy_header_line, 0, 0 },

  274.     { ngx_string("X-Accel-Limit-Rate"),
  275.                  ngx_http_upstream_process_limit_rate, 0,
  276.                  ngx_http_upstream_copy_header_line, 0, 0 },

  278.     { ngx_string("X-Accel-Buffering"),
  279.                  ngx_http_upstream_process_buffering, 0,
  280.                  ngx_http_upstream_copy_header_line, 0, 0 },

  282.     { ngx_string("X-Accel-Charset"),
  283.                  ngx_http_upstream_process_charset, 0,
  284.                  ngx_http_upstream_copy_header_line, 0, 0 },

  286.     { ngx_string("Transfer-Encoding"),
  287.                  ngx_http_upstream_process_transfer_encoding, 0,
  288.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  290. #if (NGX_HTTP_GZIP)
  291.     { ngx_string("Content-Encoding"),
  292.                  ngx_http_upstream_process_header_line,
  293.                  offsetof(ngx_http_upstream_headers_in_t, content_encoding),
  294.                  ngx_http_upstream_copy_content_encoding, 0, 0 },
  295. #endif

  297.     { ngx_null_string, NULL, 0, NULL, 0, 0 }
  298. };


  301. ‌static ngx_command_t  ngx_http_upstream_commands[] = {

  303.     { ngx_string("upstream"),
  304.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
  305.       ngx_http_upstream,
  306.       0,
  307.       0,
  308.       NULL },

  310.     { ngx_string("server"),
  311.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  312.       ngx_http_upstream_server,
  313.       NGX_HTTP_SRV_CONF_OFFSET,
  314.       0,
  315.       NULL },

  317.       ngx_null_command
  318. };


  321. ‌static ngx_http_module_t  ngx_http_upstream_module_ctx = {
  322.     ngx_http_upstream_add_variables,       /* preconfiguration */
  323.     NULL,                                  /* postconfiguration */

  325.     ngx_http_upstream_create_main_conf,    /* create main configuration */
  326.     ngx_http_upstream_init_main_conf,      /* init main configuration */

  328.     NULL,                                  /* create server configuration */
  329.     NULL,                                  /* merge server configuration */

  331.     NULL,                                  /* create location configuration */
  332.     NULL                                   /* merge location configuration */
  333. };


  336. ‌ngx_module_t  ngx_http_upstream_module = {
  337.     NGX_MODULE_V1,
  338.     &ngx_http_upstream_module_ctx,         /* module context */
  339.     ngx_http_upstream_commands,            /* module directives */
  340.     NGX_HTTP_MODULE,                       /* module type */
  341.     NULL,                                  /* init master */
  342.     NULL,                                  /* init module */
  343.     NULL,                                  /* init process */
  344.     NULL,                                  /* init thread */
  345.     NULL,                                  /* exit thread */
  346.     NULL,                                  /* exit process */
  347.     NULL,                                  /* exit master */
  348.     NGX_MODULE_V1_PADDING
  349. };


  352. ‌static ngx_http_variable_t  ngx_http_upstream_vars[] = {

  354.     { ngx_string("upstream_addr"), NULL,
  355.       ngx_http_upstream_addr_variable, 0,
  356.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  358.     { ngx_string("upstream_status"), NULL,
  359.       ngx_http_upstream_status_variable, 0,
  360.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  362.     { ngx_string("upstream_header_time"), NULL,
  363.       ngx_http_upstream_response_time_variable, 1,
  364.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  366.     { ngx_string("upstream_response_time"), NULL,
  367.       ngx_http_upstream_response_time_variable, 0,
  368.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  370.     { ngx_string("upstream_response_length"), NULL,
  371.       ngx_http_upstream_response_length_variable, 0,
  372.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  374. #if (NGX_HTTP_CACHE)

  376.     { ngx_string("upstream_cache_status"), NULL,
  377.       ngx_http_upstream_cache_status, 0,
  378.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  380.     { ngx_string("upstream_cache_last_modified"), NULL,
  381.       ngx_http_upstream_cache_last_modified, 0,
  382.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  384.     { ngx_string("upstream_cache_etag"), NULL,
  385.       ngx_http_upstream_cache_etag, 0,
  386.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  388. #endif

  390.     { ngx_null_string, NULL, NULL, 0, 0, 0 }
  391. };


  394. ‌static ngx_http_upstream_next_t  ngx_http_upstream_next_errors[] = {
  395.     { 500, NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  396.     { 502, NGX_HTTP_UPSTREAM_FT_HTTP_502 },
  397.     { 503, NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  398.     { 504, NGX_HTTP_UPSTREAM_FT_HTTP_504 },
  399.     { 403, NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  400.     { 404, NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  401.     { 0, 0 }
  402. };


  405. ‌ngx_conf_bitmask_t  ngx_http_upstream_cache_method_mask[] = {
  406.    { ngx_string("GET"),  NGX_HTTP_GET},
  407.    { ngx_string("HEAD"), NGX_HTTP_HEAD },
  408.    { ngx_string("POST"), NGX_HTTP_POST },
  409.    { ngx_null_string, 0 }
  410. };


  413. ‌ngx_conf_bitmask_t  ngx_http_upstream_ignore_headers_masks[] = {
  414.     { ngx_string("X-Accel-Redirect"), NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT },
  415.     { ngx_string("X-Accel-Expires"), NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES },
  416.     { ngx_string("X-Accel-Limit-Rate"), NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE },
  417.     { ngx_string("X-Accel-Buffering"), NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING },
  418.     { ngx_string("X-Accel-Charset"), NGX_HTTP_UPSTREAM_IGN_XA_CHARSET },
  419.     { ngx_string("Expires"), NGX_HTTP_UPSTREAM_IGN_EXPIRES },
  420.     { ngx_string("Cache-Control"), NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL },
  421.     { ngx_string("Set-Cookie"), NGX_HTTP_UPSTREAM_IGN_SET_COOKIE },
  422.     { ngx_string("Vary"), NGX_HTTP_UPSTREAM_IGN_VARY },
  423.     { ngx_null_string, 0 }
  424. };


  427. ngx_int_t
  428. ‌ngx_http_upstream_create(ngx_http_request_t *r)
  429. {
  430.     ngx_http_upstream_t  *u;

  432.     u = r->upstream;

  434.     if (u && u->cleanup) {
  435.         r->main->count++;
  436.         ngx_http_upstream_cleanup(r);
  437.     }

  439.     u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
  440.     if (u == NULL) {
  441.         return NGX_ERROR;
  442.     }

  444.     r->upstream = u;

  446.     u->peer.log = r->connection->log;
  447.     u->peer.log_error = NGX_ERROR_ERR;
  448. #if (NGX_THREADS)
  449.     u->peer.lock = &r->connection->lock;
  450. #endif

  452. #if (NGX_HTTP_CACHE)
  453.     r->cache = NULL;
  454. #endif

  456.     u->headers_in.content_length_n = -1;
  457.     u->headers_in.last_modified_time = -1;

  459.     return NGX_OK;
  460. }


  463. void
  464. ‌ngx_http_upstream_init(ngx_http_request_t *r)
  465. {
  466.     ngx_connection_t     *c;

  468.     c = r->connection;

  470.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  471.                    "http init upstream, client timer: %d", c->read->timer_set);

  473. #if (NGX_HTTP_SPDY)
  474.     if (r->spdy_stream) {
  475.         ngx_http_upstream_init_request(r);
  476.         return;
  477.     }
  478. #endif

  480.     if (c->read->timer_set) {
  481.         ngx_del_timer(c->read);
  482.     }

  484.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  486.         if (!c->write->active) {
  487.             if (ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT)
  488.                 == NGX_ERROR)
  489.             {
  490.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  491.                 return;
  492.             }
  493.         }
  494.     }

  496.     ngx_http_upstream_init_request(r);
  497. }


  500. static void
  501. ‌ngx_http_upstream_init_request(ngx_http_request_t *r)
  502. {
  503.     ngx_str_t                      *host;
  504.     ngx_uint_t                      i;
  505.     ngx_resolver_ctx_t             *ctx, temp;
  506.     ngx_http_cleanup_t             *cln;
  507.     ngx_http_upstream_t            *u;
  508.     ngx_http_core_loc_conf_t       *clcf;
  509.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  510.     ngx_http_upstream_main_conf_t  *umcf;

  512.     if (r->aio) {
  513.         return;
  514.     }

  516.     u = r->upstream;

  518. #if (NGX_HTTP_CACHE)

  520.     if (u->conf->cache) {
  521.         ngx_int_t  rc;

  523.         rc = ngx_http_upstream_cache(r, u);

  525.         if (rc == NGX_BUSY) {
  526.             r->write_event_handler = ngx_http_upstream_init_request;
  527.             return;
  528.         }

  530.         r->write_event_handler = ngx_http_request_empty_handler;

  532.         if (rc == NGX_DONE) {
  533.             return;
  534.         }

  536.         if (rc == NGX_ERROR) {
  537.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  538.             return;
  539.         }

  541.         if (rc != NGX_DECLINED) {
  542.             ngx_http_finalize_request(r, rc);
  543.             return;
  544.         }
  545.     }

  547. #endif

  549.     u->store = u->conf->store;

  551.     if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  552.         r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;
  553.         r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
  554.     }

  556.     if (r->request_body) {
  557.         u->request_bufs = r->request_body->bufs;
  558.     }

  560.     if (u->create_request(r) != NGX_OK) {
  561.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  562.         return;
  563.     }

  565.     u->peer.local = ngx_http_upstream_get_local(r, u->conf->local);

  567.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  569.     u->output.alignment = clcf->directio_alignment;
  570.     u->output.pool = r->pool;
  571.     u->output.bufs.num = 1;
  572.     u->output.bufs.size = clcf->client_body_buffer_size;
  573.     u->output.output_filter = ngx_chain_writer;
  574.     u->output.filter_ctx = &u->writer;

  576.     u->writer.pool = r->pool;

  578.     if (r->upstream_states == NULL) {

  580.         r->upstream_states = ngx_array_create(r->pool, 1,
  581.                                             sizeof(ngx_http_upstream_state_t));
  582.         if (r->upstream_states == NULL) {
  583.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  584.             return;
  585.         }

  587.     } else {

  589.         u->state = ngx_array_push(r->upstream_states);
  590.         if (u->state == NULL) {
  591.             ngx_http_upstream_finalize_request(r, u,
  592.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  593.             return;
  594.         }

  596.         ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
  597.     }

  599.     cln = ngx_http_cleanup_add(r, 0);
  600.     if (cln == NULL) {
  601.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  602.         return;
  603.     }

  605.     cln->handler = ngx_http_upstream_cleanup;
  606.     cln->data = r;
  607.     u->cleanup = &cln->handler;

  609.     if (u->resolved == NULL) {

  611.         uscf = u->conf->upstream;

  613.     } else {

  615. #if (NGX_HTTP_SSL)
  616.         u->ssl_name = u->resolved->host;
  617. #endif

  619.         if (u->resolved->sockaddr) {

  621.             if (ngx_http_upstream_create_round_robin_peer(r, u->resolved)
  622.                 != NGX_OK)
  623.             {
  624.                 ngx_http_upstream_finalize_request(r, u,
  625.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  626.                 return;
  627.             }

  629.             ngx_http_upstream_connect(r, u);

  631.             return;
  632.         }

  634.         host = &u->resolved->host;

  636.         umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  638.         uscfp = umcf->upstreams.elts;

  640.         for (i = 0; i < umcf->upstreams.nelts; i++) {

  642.             uscf = uscfp[i];

  644.             if (uscf->host.len == host->len
  645.                 && ((uscf->port == 0 && u->resolved->no_port)
  646.                      || uscf->port == u->resolved->port)
  647.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  648.             {
  649.                 goto found;
  650.             }
  651.         }

  653.         if (u->resolved->port == 0) {
  654.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  655.                           "no port in upstream \"%V\"", host);
  656.             ngx_http_upstream_finalize_request(r, u,
  657.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  658.             return;
  659.         }

  661.         temp.name = *host;

  663.         ctx = ngx_resolve_start(clcf->resolver, &temp);
  664.         if (ctx == NULL) {
  665.             ngx_http_upstream_finalize_request(r, u,
  666.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  667.             return;
  668.         }

  670.         if (ctx == NGX_NO_RESOLVER) {
  671.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  672.                           "no resolver defined to resolve %V", host);

  674.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  675.             return;
  676.         }

  678.         ctx->name = *host;
  679.         ctx->handler = ngx_http_upstream_resolve_handler;
  680.         ctx->data = r;
  681.         ctx->timeout = clcf->resolver_timeout;

  683.         u->resolved->ctx = ctx;

  685.         if (ngx_resolve_name(ctx) != NGX_OK) {
  686.             u->resolved->ctx = NULL;
  687.             ngx_http_upstream_finalize_request(r, u,
  688.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  689.             return;
  690.         }

  692.         return;
  693.     }

  695. found:

  697.     if (uscf == NULL) {
  698.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  699.                       "no upstream configuration");
  700.         ngx_http_upstream_finalize_request(r, u,
  701.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  702.         return;
  703.     }

  705. #if (NGX_HTTP_SSL)
  706.     u->ssl_name = uscf->host;
  707. #endif

  709.     if (uscf->peer.init(r, uscf) != NGX_OK) {
  710.         ngx_http_upstream_finalize_request(r, u,
  711.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  712.         return;
  713.     }

  715.     u->peer.start_time = ngx_current_msec;

  717.     if (u->conf->next_upstream_tries
  718.         && u->peer.tries > u->conf->next_upstream_tries)
  719.     {
  720.         u->peer.tries = u->conf->next_upstream_tries;
  721.     }

  723.     ngx_http_upstream_connect(r, u);
  724. }


  727. #if (NGX_HTTP_CACHE)

  729. static ngx_int_t
  730. ‌ngx_http_upstream_cache(ngx_http_request_t *r, ngx_http_upstream_t *u)
  731. {
  732.     ngx_int_t               rc;
  733.     ngx_http_cache_t       *c;
  734.     ngx_http_file_cache_t  *cache;

  736.     c = r->cache;

  738.     if (c == NULL) {

  740.         if (!(r->method & u->conf->cache_methods)) {
  741.             return NGX_DECLINED;
  742.         }

  744.         rc = ngx_http_upstream_cache_get(r, u, &cache);

  746.         if (rc != NGX_OK) {
  747.             return rc;
  748.         }

  750.         if (r->method & NGX_HTTP_HEAD) {
  751.             u->method = ngx_http_core_get_method;
  752.         }

  754.         if (ngx_http_file_cache_new(r) != NGX_OK) {
  755.             return NGX_ERROR;
  756.         }

  758.         if (u->create_key(r) != NGX_OK) {
  759.             return NGX_ERROR;
  760.         }

  762.         /* TODO: add keys */

  764.         ngx_http_file_cache_create_key(r);

  766.         if (r->cache->header_start + 256 >= u->conf->buffer_size) {
  767.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  768.                           "%V_buffer_size %uz is not enough for cache key, "
  769.                           "it should be increased to at least %uz",
  770.                           &u->conf->module, u->conf->buffer_size,
  771.                           ngx_align(r->cache->header_start + 256, 1024));

  773.             r->cache = NULL;
  774.             return NGX_DECLINED;
  775.         }

  777.         u->cacheable = 1;

  779.         c = r->cache;

  781.         c->body_start = u->conf->buffer_size;
  782.         c->min_uses = u->conf->cache_min_uses;
  783.         c->file_cache = cache;

  785.         switch (ngx_http_test_predicates(r, u->conf->cache_bypass)) {

  787.         case NGX_ERROR:
  788.             return NGX_ERROR;

  790.         case NGX_DECLINED:
  791.             u->cache_status = NGX_HTTP_CACHE_BYPASS;
  792.             return NGX_DECLINED;

  794.         default: /* NGX_OK */
  795.             break;
  796.         }

  798.         c->lock = u->conf->cache_lock;
  799.         c->lock_timeout = u->conf->cache_lock_timeout;
  800.         c->lock_age = u->conf->cache_lock_age;

  802.         u->cache_status = NGX_HTTP_CACHE_MISS;
  803.     }

  805.     rc = ngx_http_file_cache_open(r);

  807.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  808.                    "http upstream cache: %i", rc);

  810.     switch (rc) {

  812.     case NGX_HTTP_CACHE_UPDATING:

  814.         if (u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING) {
  815.             u->cache_status = rc;
  816.             rc = NGX_OK;

  818.         } else {
  819.             rc = NGX_HTTP_CACHE_STALE;
  820.         }

  822.         break;

  824.     case NGX_OK:
  825.         u->cache_status = NGX_HTTP_CACHE_HIT;
  826.     }

  828.     switch (rc) {

  830.     case NGX_OK:

  832.         rc = ngx_http_upstream_cache_send(r, u);

  834.         if (rc != NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  835.             return rc;
  836.         }

  838.         break;

  840.     case NGX_HTTP_CACHE_STALE:

  842.         c->valid_sec = 0;
  843.         u->buffer.start = NULL;
  844.         u->cache_status = NGX_HTTP_CACHE_EXPIRED;

  846.         break;

  848.     case NGX_DECLINED:

  850.         if ((size_t) (u->buffer.end - u->buffer.start) < u->conf->buffer_size) {
  851.             u->buffer.start = NULL;

  853.         } else {
  854.             u->buffer.pos = u->buffer.start + c->header_start;
  855.             u->buffer.last = u->buffer.pos;
  856.         }

  858.         break;

  860.     case NGX_HTTP_CACHE_SCARCE:

  862.         u->cacheable = 0;

  864.         break;

  866.     case NGX_AGAIN:

  868.         return NGX_BUSY;

  870.     case NGX_ERROR:

  872.         return NGX_ERROR;

  874.     default:

  876.         /* cached NGX_HTTP_BAD_GATEWAY, NGX_HTTP_GATEWAY_TIME_OUT, etc. */

  878.         u->cache_status = NGX_HTTP_CACHE_HIT;

  880.         return rc;
  881.     }

  883.     r->cached = 0;

  885.     return NGX_DECLINED;
  886. }


  889. static ngx_int_t
  890. ‌ngx_http_upstream_cache_get(ngx_http_request_t *r, ngx_http_upstream_t *u,
  891.     ngx_http_file_cache_t **cache)
  892. {
  893.     ngx_str_t               *name, val;
  894.     ngx_uint_t               i;
  895.     ngx_http_file_cache_t  **caches;

  897.     if (u->conf->cache_zone) {
  898.         *cache = u->conf->cache_zone->data;
  899.         return NGX_OK;
  900.     }

  902.     if (ngx_http_complex_value(r, u->conf->cache_value, &val) != NGX_OK) {
  903.         return NGX_ERROR;
  904.     }

  906.     if (val.len == 0
  907.         || (val.len == 3 && ngx_strncmp(val.data, "off", 3) == 0))
  908.     {
  909.         return NGX_DECLINED;
  910.     }

  912.     caches = u->caches->elts;

  914.     for (i = 0; i < u->caches->nelts; i++) {
  915.         name = &caches[i]->shm_zone->shm.name;

  917.         if (name->len == val.len
  918.             && ngx_strncmp(name->data, val.data, val.len) == 0)
  919.         {
  920.             *cache = caches[i];
  921.             return NGX_OK;
  922.         }
  923.     }

  925.     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  926.                   "cache \"%V\" not found", &val);

  928.     return NGX_ERROR;
  929. }


  932. static ngx_int_t
  933. ‌ngx_http_upstream_cache_send(ngx_http_request_t *r, ngx_http_upstream_t *u)
  934. {
  935.     ngx_int_t          rc;
  936.     ngx_http_cache_t  *c;

  938.     r->cached = 1;
  939.     c = r->cache;

  941.     if (c->header_start == c->body_start) {
  942.         r->http_version = NGX_HTTP_VERSION_9;
  943.         return ngx_http_cache_send(r);
  944.     }

  946.     /* TODO: cache stack */

  948.     u->buffer = *c->buf;
  949.     u->buffer.pos += c->header_start;

  951.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  952.     u->headers_in.content_length_n = -1;
  953.     u->headers_in.last_modified_time = -1;

  955.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  956.                       sizeof(ngx_table_elt_t))
  957.         != NGX_OK)
  958.     {
  959.         return NGX_ERROR;
  960.     }

  962.     rc = u->process_header(r);

  964.     if (rc == NGX_OK) {

  966.         if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  967.             return NGX_DONE;
  968.         }

  970.         return ngx_http_cache_send(r);
  971.     }

  973.     if (rc == NGX_ERROR) {
  974.         return NGX_ERROR;
  975.     }

  977.     /* rc == NGX_HTTP_UPSTREAM_INVALID_HEADER */

  979.     /* TODO: delete file */

  981.     return rc;
  982. }

  984. #endif


  987. static void
  988. ‌ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
  989. {
  990.     ngx_connection_t              *c;
  991.     ngx_http_request_t            *r;
  992.     ngx_http_upstream_t           *u;
  993.     ngx_http_upstream_resolved_t  *ur;

  995.     r = ctx->data;
  996.     c = r->connection;

  998.     u = r->upstream;
  999.     ur = u->resolved;

  1001.     ngx_http_set_log_request(c->log, r);

  1003.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1004.                    "http upstream resolve: \"%V?%V\"", &r->uri, &r->args);

  1006.     if (ctx->state) {
  1007.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1008.                       "%V could not be resolved (%i: %s)",
  1009.                       &ctx->name, ctx->state,
  1010.                       ngx_resolver_strerror(ctx->state));

  1012.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  1013.         goto failed;
  1014.     }

  1016.     ur->naddrs = ctx->naddrs;
  1017.     ur->addrs = ctx->addrs;

  1019. #if (NGX_DEBUG)
  1020.     {
  1021.     u_char      text[NGX_SOCKADDR_STRLEN];
  1022.     ngx_str_t   addr;
  1023.     ngx_uint_t  i;

  1025.     addr.data = text;

  1027.     for (i = 0; i < ctx->naddrs; i++) {
  1028.         addr.len = ngx_sock_ntop(ur->addrs[i].sockaddr, ur->addrs[i].socklen,
  1029.                                  text, NGX_SOCKADDR_STRLEN, 0);

  1031.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1032.                        "name was resolved to %V", &addr);
  1033.     }
  1034.     }
  1035. #endif

  1037.     if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
  1038.         ngx_http_upstream_finalize_request(r, u,
  1039.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1040.         goto failed;
  1041.     }

  1043.     ngx_resolve_name_done(ctx);
  1044.     ur->ctx = NULL;

  1046.     u->peer.start_time = ngx_current_msec;

  1048.     if (u->conf->next_upstream_tries
  1049.         && u->peer.tries > u->conf->next_upstream_tries)
  1050.     {
  1051.         u->peer.tries = u->conf->next_upstream_tries;
  1052.     }

  1054.     ngx_http_upstream_connect(r, u);

  1056. failed:

  1058.     ngx_http_run_posted_requests(c);
  1059. }


  1062. static void
  1063. ‌ngx_http_upstream_handler(ngx_event_t *ev)
  1064. {
  1065.     ngx_connection_t     *c;
  1066.     ngx_http_request_t   *r;
  1067.     ngx_http_upstream_t  *u;

  1069.     c = ev->data;
  1070.     r = c->data;

  1072.     u = r->upstream;
  1073.     c = r->connection;

  1075.     ngx_http_set_log_request(c->log, r);

  1077.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1078.                    "http upstream request: \"%V?%V\"", &r->uri, &r->args);

  1080.     if (ev->write) {
  1081.         u->write_event_handler(r, u);

  1083.     } else {
  1084.         u->read_event_handler(r, u);
  1085.     }

  1087.     ngx_http_run_posted_requests(c);
  1088. }


  1091. static void
  1092. ‌ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r)
  1093. {
  1094.     ngx_http_upstream_check_broken_connection(r, r->connection->read);
  1095. }


  1098. static void
  1099. ‌ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r)
  1100. {
  1101.     ngx_http_upstream_check_broken_connection(r, r->connection->write);
  1102. }


  1105. static void
  1106. ‌ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  1107.     ngx_event_t *ev)
  1108. {
  1109.     int                  n;
  1110.     char                 buf[1];
  1111.     ngx_err_t            err;
  1112.     ngx_int_t            event;
  1113.     ngx_connection_t     *c;
  1114.     ngx_http_upstream_t  *u;

  1116.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, ev->log, 0,
  1117.                    "http upstream check client, write event:%d, \"%V\"",
  1118.                    ev->write, &r->uri);

  1120.     c = r->connection;
  1121.     u = r->upstream;

  1123.     if (c->error) {
  1124.         if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {

  1126.             event = ev->write ? NGX_WRITE_EVENT : NGX_READ_EVENT;

  1128.             if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1129.                 ngx_http_upstream_finalize_request(r, u,
  1130.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1131.                 return;
  1132.             }
  1133.         }

  1135.         if (!u->cacheable) {
  1136.             ngx_http_upstream_finalize_request(r, u,
  1137.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1138.         }

  1140.         return;
  1141.     }

  1143. #if (NGX_HTTP_SPDY)
  1144.     if (r->spdy_stream) {
  1145.         return;
  1146.     }
  1147. #endif

  1149. #if (NGX_HAVE_KQUEUE)

  1151.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  1153.         if (!ev->pending_eof) {
  1154.             return;
  1155.         }

  1157.         ev->eof = 1;
  1158.         c->error = 1;

  1160.         if (ev->kq_errno) {
  1161.             ev->error = 1;
  1162.         }

  1164.         if (!u->cacheable && u->peer.connection) {
  1165.             ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1166.                           "kevent() reported that client prematurely closed "
  1167.                           "connection, so upstream connection is closed too");
  1168.             ngx_http_upstream_finalize_request(r, u,
  1169.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1170.             return;
  1171.         }

  1173.         ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1174.                       "kevent() reported that client prematurely closed "
  1175.                       "connection");

  1177.         if (u->peer.connection == NULL) {
  1178.             ngx_http_upstream_finalize_request(r, u,
  1179.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1180.         }

  1182.         return;
  1183.     }

  1185. #endif

  1187. #if (NGX_HAVE_EPOLLRDHUP)

  1189.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ev->pending_eof) {
  1190.         socklen_t  len;

  1192.         ev->eof = 1;
  1193.         c->error = 1;

  1195.         err = 0;
  1196.         len = sizeof(ngx_err_t);

  1198.         /*
  1199.          * BSDs and Linux return 0 and set a pending error in err
  1200.          * Solaris returns -1 and sets errno
  1201.          */

  1203.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1204.             == -1)
  1205.         {
  1206.             err = ngx_socket_errno;
  1207.         }

  1209.         if (err) {
  1210.             ev->error = 1;
  1211.         }

  1213.         if (!u->cacheable && u->peer.connection) {
  1214.             ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1215.                         "epoll_wait() reported that client prematurely closed "
  1216.                         "connection, so upstream connection is closed too");
  1217.             ngx_http_upstream_finalize_request(r, u,
  1218.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1219.             return;
  1220.         }

  1222.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1223.                       "epoll_wait() reported that client prematurely closed "
  1224.                       "connection");

  1226.         if (u->peer.connection == NULL) {
  1227.             ngx_http_upstream_finalize_request(r, u,
  1228.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1229.         }

  1231.         return;
  1232.     }

  1234. #endif

  1236.     n = recv(c->fd, buf, 1, MSG_PEEK);

  1238.     err = ngx_socket_errno;

  1240.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ev->log, err,
  1241.                    "http upstream recv(): %d", n);

  1243.     if (ev->write && (n >= 0 || err == NGX_EAGAIN)) {
  1244.         return;
  1245.     }

  1247.     if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {

  1249.         event = ev->write ? NGX_WRITE_EVENT : NGX_READ_EVENT;

  1251.         if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1252.             ngx_http_upstream_finalize_request(r, u,
  1253.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1254.             return;
  1255.         }
  1256.     }

  1258.     if (n > 0) {
  1259.         return;
  1260.     }

  1262.     if (n == -1) {
  1263.         if (err == NGX_EAGAIN) {
  1264.             return;
  1265.         }

  1267.         ev->error = 1;

  1269.     } else { /* n == 0 */
  1270.         err = 0;
  1271.     }

  1273.     ev->eof = 1;
  1274.     c->error = 1;

  1276.     if (!u->cacheable && u->peer.connection) {
  1277.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1278.                       "client prematurely closed connection, "
  1279.                       "so upstream connection is closed too");
  1280.         ngx_http_upstream_finalize_request(r, u,
  1281.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1282.         return;
  1283.     }

  1285.     ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1286.                   "client prematurely closed connection");

  1288.     if (u->peer.connection == NULL) {
  1289.         ngx_http_upstream_finalize_request(r, u,
  1290.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1291.     }
  1292. }


  1295. static void
  1296. ‌ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1297. {
  1298.     ngx_int_t          rc;
  1299.     ngx_time_t        *tp;
  1300.     ngx_connection_t  *c;

  1302.     r->connection->log->action = "connecting to upstream";

  1304.     if (u->state && u->state->response_sec) {
  1305.         tp = ngx_timeofday();
  1306.         u->state->response_sec = tp->sec - u->state->response_sec;
  1307.         u->state->response_msec = tp->msec - u->state->response_msec;
  1308.     }

  1310.     u->state = ngx_array_push(r->upstream_states);
  1311.     if (u->state == NULL) {
  1312.         ngx_http_upstream_finalize_request(r, u,
  1313.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1314.         return;
  1315.     }

  1317.     ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));

  1319.     tp = ngx_timeofday();
  1320.     u->state->response_sec = tp->sec;
  1321.     u->state->response_msec = tp->msec;
  1322.     u->state->header_sec = (time_t) NGX_ERROR;

  1324.     rc = ngx_event_connect_peer(&u->peer);

  1326.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1327.                    "http upstream connect: %i", rc);

  1329.     if (rc == NGX_ERROR) {
  1330.         ngx_http_upstream_finalize_request(r, u,
  1331.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1332.         return;
  1333.     }

  1335.     u->state->peer = u->peer.name;

  1337.     if (rc == NGX_BUSY) {
  1338.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
  1339.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);
  1340.         return;
  1341.     }

  1343.     if (rc == NGX_DECLINED) {
  1344.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1345.         return;
  1346.     }

  1348.     /* rc == NGX_OK || rc == NGX_AGAIN || rc == NGX_DONE */

  1350.     c = u->peer.connection;

  1352.     c->data = r;

  1354.     c->write->handler = ngx_http_upstream_handler;
  1355.     c->read->handler = ngx_http_upstream_handler;

  1357.     u->write_event_handler = ngx_http_upstream_send_request_handler;
  1358.     u->read_event_handler = ngx_http_upstream_process_header;

  1360.     c->sendfile &= r->connection->sendfile;
  1361.     u->output.sendfile = c->sendfile;

  1363.     if (c->pool == NULL) {

  1365.         /* we need separate pool here to be able to cache SSL connections */

  1367.         c->pool = ngx_create_pool(128, r->connection->log);
  1368.         if (c->pool == NULL) {
  1369.             ngx_http_upstream_finalize_request(r, u,
  1370.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1371.             return;
  1372.         }
  1373.     }

  1375.     c->log = r->connection->log;
  1376.     c->pool->log = c->log;
  1377.     c->read->log = c->log;
  1378.     c->write->log = c->log;

  1380.     /* init or reinit the ngx_output_chain() and ngx_chain_writer() contexts */

  1382.     u->writer.out = NULL;
  1383.     u->writer.last = &u->writer.out;
  1384.     u->writer.connection = c;
  1385.     u->writer.limit = 0;

  1387.     if (u->request_sent) {
  1388.         if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
  1389.             ngx_http_upstream_finalize_request(r, u,
  1390.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1391.             return;
  1392.         }
  1393.     }

  1395.     if (r->request_body
  1396.         && r->request_body->buf
  1397.         && r->request_body->temp_file
  1398.         && r == r->main)
  1399.     {
  1400.         /*
  1401.          * the r->request_body->buf can be reused for one request only,
  1402.          * the subrequests should allocate their own temporary bufs
  1403.          */

  1405.         u->output.free = ngx_alloc_chain_link(r->pool);
  1406.         if (u->output.free == NULL) {
  1407.             ngx_http_upstream_finalize_request(r, u,
  1408.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1409.             return;
  1410.         }

  1412.         u->output.free->buf = r->request_body->buf;
  1413.         u->output.free->next = NULL;
  1414.         u->output.allocated = 1;

  1416.         r->request_body->buf->pos = r->request_body->buf->start;
  1417.         r->request_body->buf->last = r->request_body->buf->start;
  1418.         r->request_body->buf->tag = u->output.tag;
  1419.     }

  1421.     u->request_sent = 0;

  1423.     if (rc == NGX_AGAIN) {
  1424.         ngx_add_timer(c->write, u->conf->connect_timeout);
  1425.         return;
  1426.     }

  1428. #if (NGX_HTTP_SSL)

  1430.     if (u->ssl && c->ssl == NULL) {
  1431.         ngx_http_upstream_ssl_init_connection(r, u, c);
  1432.         return;
  1433.     }

  1435. #endif

  1437.     ngx_http_upstream_send_request(r, u);
  1438. }


  1441. #if (NGX_HTTP_SSL)

  1443. static void
  1444. ‌ngx_http_upstream_ssl_init_connection(ngx_http_request_t *r,
  1445.     ngx_http_upstream_t *u, ngx_connection_t *c)
  1446. {
  1447.     ngx_int_t   rc;

  1449.     if (ngx_http_upstream_test_connect(c) != NGX_OK) {
  1450.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1451.         return;
  1452.     }

  1454.     if (ngx_ssl_create_connection(u->conf->ssl, c,
  1455.                                   NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1456.         != NGX_OK)
  1457.     {
  1458.         ngx_http_upstream_finalize_request(r, u,
  1459.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1460.         return;
  1461.     }

  1463.     c->sendfile = 0;
  1464.     u->output.sendfile = 0;

  1466.     if (u->conf->ssl_server_name || u->conf->ssl_verify) {
  1467.         if (ngx_http_upstream_ssl_name(r, u, c) != NGX_OK) {
  1468.             ngx_http_upstream_finalize_request(r, u,
  1469.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1470.             return;
  1471.         }
  1472.     }

  1474.     if (u->conf->ssl_session_reuse) {
  1475.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1476.             ngx_http_upstream_finalize_request(r, u,
  1477.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1478.             return;
  1479.         }
  1480.     }

  1482.     r->connection->log->action = "SSL handshaking to upstream";

  1484.     rc = ngx_ssl_handshake(c);

  1486.     if (rc == NGX_AGAIN) {

  1488.         if (!c->write->timer_set) {
  1489.             ngx_add_timer(c->write, u->conf->connect_timeout);
  1490.         }

  1492.         c->ssl->handler = ngx_http_upstream_ssl_handshake;
  1493.         return;
  1494.     }

  1496.     ngx_http_upstream_ssl_handshake(c);
  1497. }


  1500. static void
  1501. ‌ngx_http_upstream_ssl_handshake(ngx_connection_t *c)
  1502. {
  1503.     long                  rc;
  1504.     ngx_http_request_t   *r;
  1505.     ngx_http_upstream_t  *u;

  1507.     r = c->data;
  1508.     u = r->upstream;

  1510.     ngx_http_set_log_request(c->log, r);

  1512.     if (c->ssl->handshaked) {

  1514.         if (u->conf->ssl_verify) {
  1515.             rc = SSL_get_verify_result(c->ssl->connection);

  1517.             if (rc != X509_V_OK) {
  1518.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1519.                               "upstream SSL certificate verify error: (%l:%s)",
  1520.                               rc, X509_verify_cert_error_string(rc));
  1521.                 goto failed;
  1522.             }

  1524.             if (ngx_ssl_check_host(c, &u->ssl_name) != NGX_OK) {
  1525.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1526.                               "upstream SSL certificate does not match \"%V\"",
  1527.                               &u->ssl_name);
  1528.                 goto failed;
  1529.             }
  1530.         }

  1532.         if (u->conf->ssl_session_reuse) {
  1533.             u->peer.save_session(&u->peer, u->peer.data);
  1534.         }

  1536.         c->write->handler = ngx_http_upstream_handler;
  1537.         c->read->handler = ngx_http_upstream_handler;

  1539.         c = r->connection;

  1541.         ngx_http_upstream_send_request(r, u);

  1543.         ngx_http_run_posted_requests(c);
  1544.         return;
  1545.     }

  1547. failed:

  1549.     c = r->connection;

  1551.     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);

  1553.     ngx_http_run_posted_requests(c);
  1554. }


  1557. static ngx_int_t
  1558. ‌ngx_http_upstream_ssl_name(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1559.     ngx_connection_t *c)
  1560. {
  1561.     u_char     *p, *last;
  1562.     ngx_str_t   name;

  1564.     if (u->conf->ssl_name) {
  1565.         if (ngx_http_complex_value(r, u->conf->ssl_name, &name) != NGX_OK) {
  1566.             return NGX_ERROR;
  1567.         }

  1569.     } else {
  1570.         name = u->ssl_name;
  1571.     }

  1573.     if (name.len == 0) {
  1574.         goto done;
  1575.     }

  1577.     /*
  1578.      * ssl name here may contain port, notably if derived from $proxy_host
  1579.      * or $http_host; we have to strip it
  1580.      */

  1582.     p = name.data;
  1583.     last = name.data + name.len;

  1585.     if (*p == '[') {
  1586.         p = ngx_strlchr(p, last, ']');

  1588.         if (p == NULL) {
  1589.             p = name.data;
  1590.         }
  1591.     }

  1593.     p = ngx_strlchr(p, last, ':');

  1595.     if (p != NULL) {
  1596.         name.len = p - name.data;
  1597.     }

  1599.     if (!u->conf->ssl_server_name) {
  1600.         goto done;
  1601.     }

  1603. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  1605.     /* as per RFC 6066, literal IPv4 and IPv6 addresses are not permitted */

  1607.     if (name.len == 0 || *name.data == '[') {
  1608.         goto done;
  1609.     }

  1611.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1612.         goto done;
  1613.     }

  1615.     /*
  1616.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1617.      * hence we explicitly null-terminate name here
  1618.      */

  1620.     p = ngx_pnalloc(r->pool, name.len + 1);
  1621.     if (p == NULL) {
  1622.         return NGX_ERROR;
  1623.     }

  1625.     (void) ngx_cpystrn(p, name.data, name.len + 1);

  1627.     name.data = p;

  1629.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1630.                    "upstream SSL server name: \"%s\"", name.data);

  1632.     if (SSL_set_tlsext_host_name(c->ssl->connection, name.data) == 0) {
  1633.         ngx_ssl_error(NGX_LOG_ERR, r->connection->log, 0,
  1634.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  1635.         return NGX_ERROR;
  1636.     }

  1638. #endif

  1640. done:

  1642.     u->ssl_name = name;

  1644.     return NGX_OK;
  1645. }

  1647. #endif


  1650. static ngx_int_t
  1651. ‌ngx_http_upstream_reinit(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1652. {
  1653.     off_t         file_pos;
  1654.     ngx_chain_t  *cl;

  1656.     if (u->reinit_request(r) != NGX_OK) {
  1657.         return NGX_ERROR;
  1658.     }

  1660.     u->keepalive = 0;
  1661.     u->upgrade = 0;

  1663.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  1664.     u->headers_in.content_length_n = -1;
  1665.     u->headers_in.last_modified_time = -1;

  1667.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  1668.                       sizeof(ngx_table_elt_t))
  1669.         != NGX_OK)
  1670.     {
  1671.         return NGX_ERROR;
  1672.     }

  1674.     /* reinit the request chain */

  1676.     file_pos = 0;

  1678.     for (cl = u->request_bufs; cl; cl = cl->next) {
  1679.         cl->buf->pos = cl->buf->start;

  1681.         /* there is at most one file */

  1683.         if (cl->buf->in_file) {
  1684.             cl->buf->file_pos = file_pos;
  1685.             file_pos = cl->buf->file_last;
  1686.         }
  1687.     }

  1689.     /* reinit the subrequest's ngx_output_chain() context */

  1691.     if (r->request_body && r->request_body->temp_file
  1692.         && r != r->main && u->output.buf)
  1693.     {
  1694.         u->output.free = ngx_alloc_chain_link(r->pool);
  1695.         if (u->output.free == NULL) {
  1696.             return NGX_ERROR;
  1697.         }

  1699.         u->output.free->buf = u->output.buf;
  1700.         u->output.free->next = NULL;

  1702.         u->output.buf->pos = u->output.buf->start;
  1703.         u->output.buf->last = u->output.buf->start;
  1704.     }

  1706.     u->output.buf = NULL;
  1707.     u->output.in = NULL;
  1708.     u->output.busy = NULL;

  1710.     /* reinit u->buffer */

  1712.     u->buffer.pos = u->buffer.start;

  1714. #if (NGX_HTTP_CACHE)

  1716.     if (r->cache) {
  1717.         u->buffer.pos += r->cache->header_start;
  1718.     }

  1720. #endif

  1722.     u->buffer.last = u->buffer.pos;

  1724.     return NGX_OK;
  1725. }


  1728. static void
  1729. ‌ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1730. {
  1731.     ngx_int_t          rc;
  1732.     ngx_connection_t  *c;

  1734.     c = u->peer.connection;

  1736.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1737.                    "http upstream send request");

  1739.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  1740.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1741.         return;
  1742.     }

  1744.     c->log->action = "sending request to upstream";

  1746.     rc = ngx_output_chain(&u->output, u->request_sent ? NULL : u->request_bufs);

  1748.     u->request_sent = 1;

  1750.     if (rc == NGX_ERROR) {
  1751.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1752.         return;
  1753.     }

  1755.     if (c->write->timer_set) {
  1756.         ngx_del_timer(c->write);
  1757.     }

  1759.     if (rc == NGX_AGAIN) {
  1760.         ngx_add_timer(c->write, u->conf->send_timeout);

  1762.         if (ngx_handle_write_event(c->write, u->conf->send_lowat) != NGX_OK) {
  1763.             ngx_http_upstream_finalize_request(r, u,
  1764.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1765.             return;
  1766.         }

  1768.         return;
  1769.     }

  1771.     /* rc == NGX_OK */

  1773.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  1774.         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
  1775.             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  1776.                           ngx_tcp_push_n " failed");
  1777.             ngx_http_upstream_finalize_request(r, u,
  1778.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1779.             return;
  1780.         }

  1782.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  1783.     }

  1785.     u->write_event_handler = ngx_http_upstream_dummy_handler;

  1787.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  1788.         ngx_http_upstream_finalize_request(r, u,
  1789.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1790.         return;
  1791.     }

  1793.     ngx_add_timer(c->read, u->conf->read_timeout);

  1795.     if (c->read->ready) {
  1796.         ngx_http_upstream_process_header(r, u);
  1797.         return;
  1798.     }
  1799. }


  1802. static void
  1803. ‌ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  1804.     ngx_http_upstream_t *u)
  1805. {
  1806.     ngx_connection_t  *c;

  1808.     c = u->peer.connection;

  1810.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1811.                    "http upstream send request handler");

  1813.     if (c->write->timedout) {
  1814.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  1815.         return;
  1816.     }

  1818. #if (NGX_HTTP_SSL)

  1820.     if (u->ssl && c->ssl == NULL) {
  1821.         ngx_http_upstream_ssl_init_connection(r, u, c);
  1822.         return;
  1823.     }

  1825. #endif

  1827.     if (u->header_sent) {
  1828.         u->write_event_handler = ngx_http_upstream_dummy_handler;

  1830.         (void) ngx_handle_write_event(c->write, 0);

  1832.         return;
  1833.     }

  1835.     ngx_http_upstream_send_request(r, u);
  1836. }


  1839. static void
  1840. ‌ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1841. {
  1842.     ssize_t            n;
  1843.     ngx_int_t          rc;
  1844.     ngx_time_t        *tp;
  1845.     ngx_connection_t  *c;

  1847.     c = u->peer.connection;

  1849.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1850.                    "http upstream process header");

  1852.     c->log->action = "reading response header from upstream";

  1854.     if (c->read->timedout) {
  1855.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  1856.         return;
  1857.     }

  1859.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  1860.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1861.         return;
  1862.     }

  1864.     if (u->buffer.start == NULL) {
  1865.         u->buffer.start = ngx_palloc(r->pool, u->conf->buffer_size);
  1866.         if (u->buffer.start == NULL) {
  1867.             ngx_http_upstream_finalize_request(r, u,
  1868.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1869.             return;
  1870.         }

  1872.         u->buffer.pos = u->buffer.start;
  1873.         u->buffer.last = u->buffer.start;
  1874.         u->buffer.end = u->buffer.start + u->conf->buffer_size;
  1875.         u->buffer.temporary = 1;

  1877.         u->buffer.tag = u->output.tag;

  1879.         if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  1880.                           sizeof(ngx_table_elt_t))
  1881.             != NGX_OK)
  1882.         {
  1883.             ngx_http_upstream_finalize_request(r, u,
  1884.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1885.             return;
  1886.         }

  1888. #if (NGX_HTTP_CACHE)

  1890.         if (r->cache) {
  1891.             u->buffer.pos += r->cache->header_start;
  1892.             u->buffer.last = u->buffer.pos;
  1893.         }
  1894. #endif
  1895.     }

  1897.     for ( ;; ) {

  1899.         n = c->recv(c, u->buffer.last, u->buffer.end - u->buffer.last);

  1901.         if (n == NGX_AGAIN) {
  1902. #if 0
  1903.             ngx_add_timer(rev, u->read_timeout);
  1904. #endif

  1906.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  1907.                 ngx_http_upstream_finalize_request(r, u,
  1908.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1909.                 return;
  1910.             }

  1912.             return;
  1913.         }

  1915.         if (n == 0) {
  1916.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1917.                           "upstream prematurely closed connection");
  1918.         }

  1920.         if (n == NGX_ERROR || n == 0) {
  1921.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1922.             return;
  1923.         }

  1925.         u->buffer.last += n;

  1927. #if 0
  1928.         u->valid_header_in = 0;

  1930.         u->peer.cached = 0;
  1931. #endif

  1933.         rc = u->process_header(r);

  1935.         if (rc == NGX_AGAIN) {

  1937.             if (u->buffer.last == u->buffer.end) {
  1938.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1939.                               "upstream sent too big header");

  1941.                 ngx_http_upstream_next(r, u,
  1942.                                        NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  1943.                 return;
  1944.             }

  1946.             continue;
  1947.         }

  1949.         break;
  1950.     }

  1952.     if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  1953.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  1954.         return;
  1955.     }

  1957.     if (rc == NGX_ERROR) {
  1958.         ngx_http_upstream_finalize_request(r, u,
  1959.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1960.         return;
  1961.     }

  1963.     /* rc == NGX_OK */

  1965.     tp = ngx_timeofday();
  1966.     u->state->header_sec = tp->sec - u->state->response_sec;
  1967.     u->state->header_msec = tp->msec - u->state->response_msec;

  1969.     if (u->headers_in.status_n >= NGX_HTTP_SPECIAL_RESPONSE) {

  1971.         if (ngx_http_upstream_test_next(r, u) == NGX_OK) {
  1972.             return;
  1973.         }

  1975.         if (ngx_http_upstream_intercept_errors(r, u) == NGX_OK) {
  1976.             return;
  1977.         }
  1978.     }

  1980.     if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  1981.         return;
  1982.     }

  1984.     if (!r->subrequest_in_memory) {
  1985.         ngx_http_upstream_send_response(r, u);
  1986.         return;
  1987.     }

  1989.     /* subrequest content in memory */

  1991.     if (u->input_filter == NULL) {
  1992.         u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
  1993.         u->input_filter = ngx_http_upstream_non_buffered_filter;
  1994.         u->input_filter_ctx = r;
  1995.     }

  1997.     if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
  1998.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  1999.         return;
  2000.     }

  2002.     n = u->buffer.last - u->buffer.pos;

  2004.     if (n) {
  2005.         u->buffer.last = u->buffer.pos;

  2007.         u->state->response_length += n;

  2009.         if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  2010.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2011.             return;
  2012.         }
  2013.     }

  2015.     if (u->length == 0) {
  2016.         ngx_http_upstream_finalize_request(r, u, 0);
  2017.         return;
  2018.     }

  2020.     u->read_event_handler = ngx_http_upstream_process_body_in_memory;

  2022.     ngx_http_upstream_process_body_in_memory(r, u);
  2023. }


  2026. static ngx_int_t
  2027. ‌ngx_http_upstream_test_next(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2028. {
  2029.     ngx_uint_t                 status;
  2030.     ngx_http_upstream_next_t  *un;

  2032.     status = u->headers_in.status_n;

  2034.     for (un = ngx_http_upstream_next_errors; un->status; un++) {

  2036.         if (status != un->status) {
  2037.             continue;
  2038.         }

  2040.         if (u->peer.tries > 1 && (u->conf->next_upstream & un->mask)) {
  2041.             ngx_http_upstream_next(r, u, un->mask);
  2042.             return NGX_OK;
  2043.         }

  2045. #if (NGX_HTTP_CACHE)

  2047.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2048.             && (u->conf->cache_use_stale & un->mask))
  2049.         {
  2050.             ngx_int_t  rc;

  2052.             rc = u->reinit_request(r);

  2054.             if (rc == NGX_OK) {
  2055.                 u->cache_status = NGX_HTTP_CACHE_STALE;
  2056.                 rc = ngx_http_upstream_cache_send(r, u);
  2057.             }

  2059.             ngx_http_upstream_finalize_request(r, u, rc);
  2060.             return NGX_OK;
  2061.         }

  2063. #endif
  2064.     }

  2066. #if (NGX_HTTP_CACHE)

  2068.     if (status == NGX_HTTP_NOT_MODIFIED
  2069.         && u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2070.         && u->conf->cache_revalidate)
  2071.     {
  2072.         time_t     now, valid;
  2073.         ngx_int_t  rc;

  2075.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2076.                        "http upstream not modified");

  2078.         now = ngx_time();
  2079.         valid = r->cache->valid_sec;

  2081.         rc = u->reinit_request(r);

  2083.         if (rc != NGX_OK) {
  2084.             ngx_http_upstream_finalize_request(r, u, rc);
  2085.             return NGX_OK;
  2086.         }

  2088.         u->cache_status = NGX_HTTP_CACHE_REVALIDATED;
  2089.         rc = ngx_http_upstream_cache_send(r, u);

  2091.         if (valid == 0) {
  2092.             valid = r->cache->valid_sec;
  2093.         }

  2095.         if (valid == 0) {
  2096.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2097.                                               u->headers_in.status_n);
  2098.             if (valid) {
  2099.                 valid = now + valid;
  2100.             }
  2101.         }

  2103.         if (valid) {
  2104.             r->cache->valid_sec = valid;
  2105.             r->cache->date = now;

  2107.             ngx_http_file_cache_update_header(r);
  2108.         }

  2110.         ngx_http_upstream_finalize_request(r, u, rc);
  2111.         return NGX_OK;
  2112.     }

  2114. #endif

  2116.     return NGX_DECLINED;
  2117. }


  2120. static ngx_int_t
  2121. ‌ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  2122.     ngx_http_upstream_t *u)
  2123. {
  2124.     ngx_int_t                  status;
  2125.     ngx_uint_t                 i;
  2126.     ngx_table_elt_t           *h;
  2127.     ngx_http_err_page_t       *err_page;
  2128.     ngx_http_core_loc_conf_t  *clcf;

  2130.     status = u->headers_in.status_n;

  2132.     if (status == NGX_HTTP_NOT_FOUND && u->conf->intercept_404) {
  2133.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_NOT_FOUND);
  2134.         return NGX_OK;
  2135.     }

  2137.     if (!u->conf->intercept_errors) {
  2138.         return NGX_DECLINED;
  2139.     }

  2141.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2143.     if (clcf->error_pages == NULL) {
  2144.         return NGX_DECLINED;
  2145.     }

  2147.     err_page = clcf->error_pages->elts;
  2148.     for (i = 0; i < clcf->error_pages->nelts; i++) {

  2150.         if (err_page[i].status == status) {

  2152.             if (status == NGX_HTTP_UNAUTHORIZED
  2153.                 && u->headers_in.www_authenticate)
  2154.             {
  2155.                 h = ngx_list_push(&r->headers_out.headers);

  2157.                 if (h == NULL) {
  2158.                     ngx_http_upstream_finalize_request(r, u,
  2159.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2160.                     return NGX_OK;
  2161.                 }

  2163.                 *h = *u->headers_in.www_authenticate;

  2165.                 r->headers_out.www_authenticate = h;
  2166.             }

  2168. #if (NGX_HTTP_CACHE)

  2170.             if (r->cache) {
  2171.                 time_t  valid;

  2173.                 valid = ngx_http_file_cache_valid(u->conf->cache_valid, status);

  2175.                 if (valid) {
  2176.                     r->cache->valid_sec = ngx_time() + valid;
  2177.                     r->cache->error = status;
  2178.                 }

  2180.                 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  2181.             }
  2182. #endif
  2183.             ngx_http_upstream_finalize_request(r, u, status);

  2185.             return NGX_OK;
  2186.         }
  2187.     }

  2189.     return NGX_DECLINED;
  2190. }


  2193. static ngx_int_t
  2194. ‌ngx_http_upstream_test_connect(ngx_connection_t *c)
  2195. {
  2196.     int        err;
  2197.     socklen_t  len;

  2199. #if (NGX_HAVE_KQUEUE)

  2201.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
  2202.         if (c->write->pending_eof || c->read->pending_eof) {
  2203.             if (c->write->pending_eof) {
  2204.                 err = c->write->kq_errno;

  2206.             } else {
  2207.                 err = c->read->kq_errno;
  2208.             }

  2210.             c->log->action = "connecting to upstream";
  2211.             (void) ngx_connection_error(c, err,
  2212.                                     "kevent() reported that connect() failed");
  2213.             return NGX_ERROR;
  2214.         }

  2216.     } else
  2217. #endif
  2218.     {
  2219.         err = 0;
  2220.         len = sizeof(int);

  2222.         /*
  2223.          * BSDs and Linux return 0 and set a pending error in err
  2224.          * Solaris returns -1 and sets errno
  2225.          */

  2227.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  2228.             == -1)
  2229.         {
  2230.             err = ngx_socket_errno;
  2231.         }

  2233.         if (err) {
  2234.             c->log->action = "connecting to upstream";
  2235.             (void) ngx_connection_error(c, err, "connect() failed");
  2236.             return NGX_ERROR;
  2237.         }
  2238.     }

  2240.     return NGX_OK;
  2241. }


  2244. static ngx_int_t
  2245. ‌ngx_http_upstream_process_headers(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2246. {
  2247.     ngx_str_t                       uri, args;
  2248.     ngx_uint_t                      i, flags;
  2249.     ngx_list_part_t                *part;
  2250.     ngx_table_elt_t                *h;
  2251.     ngx_http_upstream_header_t     *hh;
  2252.     ngx_http_upstream_main_conf_t  *umcf;

  2254.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  2256.     if (u->headers_in.x_accel_redirect
  2257.         && !(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT))
  2258.     {
  2259.         ngx_http_upstream_finalize_request(r, u, NGX_DECLINED);

  2261.         part = &u->headers_in.headers.part;
  2262.         h = part->elts;

  2264.         for (i = 0; /* void */; i++) {

  2266.             if (i >= part->nelts) {
  2267.                 if (part->next == NULL) {
  2268.                     break;
  2269.                 }

  2271.                 part = part->next;
  2272.                 h = part->elts;
  2273.                 i = 0;
  2274.             }

  2276.             hh = ngx_hash_find(&umcf->headers_in_hash, h[i].hash,
  2277.                                h[i].lowcase_key, h[i].key.len);

  2279.             if (hh && hh->redirect) {
  2280.                 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  2281.                     ngx_http_finalize_request(r,
  2282.                                               NGX_HTTP_INTERNAL_SERVER_ERROR);
  2283.                     return NGX_DONE;
  2284.                 }
  2285.             }
  2286.         }

  2288.         uri = u->headers_in.x_accel_redirect->value;

  2290.         if (uri.data[0] == '@') {
  2291.             ngx_http_named_location(r, &uri);

  2293.         } else {
  2294.             ngx_str_null(&args);
  2295.             flags = NGX_HTTP_LOG_UNSAFE;

  2297.             if (ngx_http_parse_unsafe_uri(r, &uri, &args, &flags) != NGX_OK) {
  2298.                 ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  2299.                 return NGX_DONE;
  2300.             }

  2302.             if (r->method != NGX_HTTP_HEAD) {
  2303.                 r->method = NGX_HTTP_GET;
  2304.             }

  2306.             ngx_http_internal_redirect(r, &uri, &args);
  2307.         }

  2309.         ngx_http_finalize_request(r, NGX_DONE);
  2310.         return NGX_DONE;
  2311.     }

  2313.     part = &u->headers_in.headers.part;
  2314.     h = part->elts;

  2316.     for (i = 0; /* void */; i++) {

  2318.         if (i >= part->nelts) {
  2319.             if (part->next == NULL) {
  2320.                 break;
  2321.             }

  2323.             part = part->next;
  2324.             h = part->elts;
  2325.             i = 0;
  2326.         }

  2328.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  2329.                           h[i].lowcase_key, h[i].key.len))
  2330.         {
  2331.             continue;
  2332.         }

  2334.         hh = ngx_hash_find(&umcf->headers_in_hash, h[i].hash,
  2335.                            h[i].lowcase_key, h[i].key.len);

  2337.         if (hh) {
  2338.             if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  2339.                 ngx_http_upstream_finalize_request(r, u,
  2340.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2341.                 return NGX_DONE;
  2342.             }

  2344.             continue;
  2345.         }

  2347.         if (ngx_http_upstream_copy_header_line(r, &h[i], 0) != NGX_OK) {
  2348.             ngx_http_upstream_finalize_request(r, u,
  2349.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2350.             return NGX_DONE;
  2351.         }
  2352.     }

  2354.     if (r->headers_out.server && r->headers_out.server->value.data == NULL) {
  2355.         r->headers_out.server->hash = 0;
  2356.     }

  2358.     if (r->headers_out.date && r->headers_out.date->value.data == NULL) {
  2359.         r->headers_out.date->hash = 0;
  2360.     }

  2362.     r->headers_out.status = u->headers_in.status_n;
  2363.     r->headers_out.status_line = u->headers_in.status_line;

  2365.     r->headers_out.content_length_n = u->headers_in.content_length_n;

  2367.     r->disable_not_modified = !u->cacheable;

  2369.     if (u->conf->force_ranges) {
  2370.         r->allow_ranges = 1;
  2371.         r->single_range = 1;

  2373. #if (NGX_HTTP_CACHE)
  2374.         if (r->cached) {
  2375.             r->single_range = 0;
  2376.         }
  2377. #endif
  2378.     }

  2380.     u->length = -1;

  2382.     return NGX_OK;
  2383. }


  2386. static void
  2387. ‌ngx_http_upstream_process_body_in_memory(ngx_http_request_t *r,
  2388.     ngx_http_upstream_t *u)
  2389. {
  2390.     size_t             size;
  2391.     ssize_t            n;
  2392.     ngx_buf_t         *b;
  2393.     ngx_event_t       *rev;
  2394.     ngx_connection_t  *c;

  2396.     c = u->peer.connection;
  2397.     rev = c->read;

  2399.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2400.                    "http upstream process body on memory");

  2402.     if (rev->timedout) {
  2403.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  2404.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  2405.         return;
  2406.     }

  2408.     b = &u->buffer;

  2410.     for ( ;; ) {

  2412.         size = b->end - b->last;

  2414.         if (size == 0) {
  2415.             ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  2416.                           "upstream buffer is too small to read response");
  2417.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2418.             return;
  2419.         }

  2421.         n = c->recv(c, b->last, size);

  2423.         if (n == NGX_AGAIN) {
  2424.             break;
  2425.         }

  2427.         if (n == 0 || n == NGX_ERROR) {
  2428.             ngx_http_upstream_finalize_request(r, u, n);
  2429.             return;
  2430.         }

  2432.         u->state->response_length += n;

  2434.         if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  2435.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2436.             return;
  2437.         }

  2439.         if (!rev->ready) {
  2440.             break;
  2441.         }
  2442.     }

  2444.     if (u->length == 0) {
  2445.         ngx_http_upstream_finalize_request(r, u, 0);
  2446.         return;
  2447.     }

  2449.     if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  2450.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2451.         return;
  2452.     }

  2454.     if (rev->active) {
  2455.         ngx_add_timer(rev, u->conf->read_timeout);

  2457.     } else if (rev->timer_set) {
  2458.         ngx_del_timer(rev);
  2459.     }
  2460. }


  2463. static void
  2464. ‌ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2465. {
  2466.     int                        tcp_nodelay;
  2467.     ssize_t                    n;
  2468.     ngx_int_t                  rc;
  2469.     ngx_event_pipe_t          *p;
  2470.     ngx_connection_t          *c;
  2471.     ngx_http_core_loc_conf_t  *clcf;

  2473.     rc = ngx_http_send_header(r);

  2475.     if (rc == NGX_ERROR || rc > NGX_OK || r->post_action) {
  2476.         ngx_http_upstream_finalize_request(r, u, rc);
  2477.         return;
  2478.     }

  2480.     u->header_sent = 1;

  2482.     if (u->upgrade) {
  2483.         ngx_http_upstream_upgrade(r, u);
  2484.         return;
  2485.     }

  2487.     c = r->connection;

  2489.     if (r->header_only) {

  2491.         if (!u->buffering) {
  2492.             ngx_http_upstream_finalize_request(r, u, rc);
  2493.             return;
  2494.         }

  2496.         if (!u->cacheable && !u->store) {
  2497.             ngx_http_upstream_finalize_request(r, u, rc);
  2498.             return;
  2499.         }

  2501.         u->pipe->downstream_error = 1;
  2502.     }

  2504.     if (r->request_body && r->request_body->temp_file) {
  2505.         ngx_pool_run_cleanup_file(r->pool, r->request_body->temp_file->file.fd);
  2506.         r->request_body->temp_file->file.fd = NGX_INVALID_FILE;
  2507.     }

  2509.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2511.     if (!u->buffering) {

  2513.         if (u->input_filter == NULL) {
  2514.             u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
  2515.             u->input_filter = ngx_http_upstream_non_buffered_filter;
  2516.             u->input_filter_ctx = r;
  2517.         }

  2519.         u->read_event_handler = ngx_http_upstream_process_non_buffered_upstream;
  2520.         r->write_event_handler =
  2521.                              ngx_http_upstream_process_non_buffered_downstream;

  2523.         r->limit_rate = 0;

  2525.         if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
  2526.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2527.             return;
  2528.         }

  2530.         if (clcf->tcp_nodelay && c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
  2531.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");

  2533.             tcp_nodelay = 1;

  2535.             if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
  2536.                                (const void *) &tcp_nodelay, sizeof(int)) == -1)
  2537.             {
  2538.                 ngx_connection_error(c, ngx_socket_errno,
  2539.                                      "setsockopt(TCP_NODELAY) failed");
  2540.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2541.                 return;
  2542.             }

  2544.             c->tcp_nodelay = NGX_TCP_NODELAY_SET;
  2545.         }

  2547.         n = u->buffer.last - u->buffer.pos;

  2549.         if (n) {
  2550.             u->buffer.last = u->buffer.pos;

  2552.             u->state->response_length += n;

  2554.             if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  2555.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2556.                 return;
  2557.             }

  2559.             ngx_http_upstream_process_non_buffered_downstream(r);

  2561.         } else {
  2562.             u->buffer.pos = u->buffer.start;
  2563.             u->buffer.last = u->buffer.start;

  2565.             if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  2566.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2567.                 return;
  2568.             }

  2570.             if (u->peer.connection->read->ready || u->length == 0) {
  2571.                 ngx_http_upstream_process_non_buffered_upstream(r, u);
  2572.             }
  2573.         }

  2575.         return;
  2576.     }

  2578.     /* TODO: preallocate event_pipe bufs, look "Content-Length" */

  2580. #if (NGX_HTTP_CACHE)

  2582.     if (r->cache && r->cache->file.fd != NGX_INVALID_FILE) {
  2583.         ngx_pool_run_cleanup_file(r->pool, r->cache->file.fd);
  2584.         r->cache->file.fd = NGX_INVALID_FILE;
  2585.     }

  2587.     switch (ngx_http_test_predicates(r, u->conf->no_cache)) {

  2589.     case NGX_ERROR:
  2590.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2591.         return;

  2593.     case NGX_DECLINED:
  2594.         u->cacheable = 0;
  2595.         break;

  2597.     default: /* NGX_OK */

  2599.         if (u->cache_status == NGX_HTTP_CACHE_BYPASS) {

  2601.             /* create cache if previously bypassed */

  2603.             if (ngx_http_file_cache_create(r) != NGX_OK) {
  2604.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2605.                 return;
  2606.             }
  2607.         }

  2609.         break;
  2610.     }

  2612.     if (u->cacheable) {
  2613.         time_t  now, valid;

  2615.         now = ngx_time();

  2617.         valid = r->cache->valid_sec;

  2619.         if (valid == 0) {
  2620.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2621.                                               u->headers_in.status_n);
  2622.             if (valid) {
  2623.                 r->cache->valid_sec = now + valid;
  2624.             }
  2625.         }

  2627.         if (valid) {
  2628.             r->cache->date = now;
  2629.             r->cache->body_start = (u_short) (u->buffer.pos - u->buffer.start);

  2631.             if (u->headers_in.status_n == NGX_HTTP_OK
  2632.                 || u->headers_in.status_n == NGX_HTTP_PARTIAL_CONTENT)
  2633.             {
  2634.                 r->cache->last_modified = u->headers_in.last_modified_time;

  2636.                 if (u->headers_in.etag) {
  2637.                     r->cache->etag = u->headers_in.etag->value;
  2638.                 }
  2639.             }

  2641.             if (ngx_http_file_cache_set_header(r, u->buffer.start) != NGX_OK) {
  2642.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2643.                 return;
  2644.             }

  2646.         } else {
  2647.             u->cacheable = 0;
  2648.         }
  2649.     }

  2651.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2652.                    "http cacheable: %d", u->cacheable);

  2654.     if (u->cacheable == 0 && r->cache) {
  2655.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  2656.     }

  2658. #endif

  2660.     p = u->pipe;

  2662.     p->output_filter = (ngx_event_pipe_output_filter_pt) ngx_http_output_filter;
  2663.     p->output_ctx = r;
  2664.     p->tag = u->output.tag;
  2665.     p->bufs = u->conf->bufs;
  2666.     p->busy_size = u->conf->busy_buffers_size;
  2667.     p->upstream = u->peer.connection;
  2668.     p->downstream = c;
  2669.     p->pool = r->pool;
  2670.     p->log = c->log;
  2671.     p->limit_rate = u->conf->limit_rate;
  2672.     p->start_sec = ngx_time();

  2674.     p->cacheable = u->cacheable || u->store;

  2676.     p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  2677.     if (p->temp_file == NULL) {
  2678.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2679.         return;
  2680.     }

  2682.     p->temp_file->file.fd = NGX_INVALID_FILE;
  2683.     p->temp_file->file.log = c->log;
  2684.     p->temp_file->path = u->conf->temp_path;
  2685.     p->temp_file->pool = r->pool;

  2687.     if (p->cacheable) {
  2688.         p->temp_file->persistent = 1;

  2690. #if (NGX_HTTP_CACHE)
  2691.         if (r->cache && r->cache->file_cache->temp_path) {
  2692.             p->temp_file->path = r->cache->file_cache->temp_path;
  2693.         }
  2694. #endif

  2696.     } else {
  2697.         p->temp_file->log_level = NGX_LOG_WARN;
  2698.         p->temp_file->warn = "an upstream response is buffered "
  2699.                              "to a temporary file";
  2700.     }

  2702.     p->max_temp_file_size = u->conf->max_temp_file_size;
  2703.     p->temp_file_write_size = u->conf->temp_file_write_size;

  2705.     p->preread_bufs = ngx_alloc_chain_link(r->pool);
  2706.     if (p->preread_bufs == NULL) {
  2707.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2708.         return;
  2709.     }

  2711.     p->preread_bufs->buf = &u->buffer;
  2712.     p->preread_bufs->next = NULL;
  2713.     u->buffer.recycled = 1;

  2715.     p->preread_size = u->buffer.last - u->buffer.pos;

  2717.     if (u->cacheable) {

  2719.         p->buf_to_file = ngx_calloc_buf(r->pool);
  2720.         if (p->buf_to_file == NULL) {
  2721.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2722.             return;
  2723.         }

  2725.         p->buf_to_file->start = u->buffer.start;
  2726.         p->buf_to_file->pos = u->buffer.start;
  2727.         p->buf_to_file->last = u->buffer.pos;
  2728.         p->buf_to_file->temporary = 1;
  2729.     }

  2731.     if (ngx_event_flags & NGX_USE_AIO_EVENT) {
  2732.         /* the posted aio operation may corrupt a shadow buffer */
  2733.         p->single_buf = 1;
  2734.     }

  2736.     /* TODO: p->free_bufs = 0 if use ngx_create_chain_of_bufs() */
  2737.     p->free_bufs = 1;

  2739.     /*
  2740.      * event_pipe would do u->buffer.last += p->preread_size
  2741.      * as though these bytes were read
  2742.      */
  2743.     u->buffer.last = u->buffer.pos;

  2745.     if (u->conf->cyclic_temp_file) {

  2747.         /*
  2748.          * we need to disable the use of sendfile() if we use cyclic temp file
  2749.          * because the writing a new data may interfere with sendfile()
  2750.          * that uses the same kernel file pages (at least on FreeBSD)
  2751.          */

  2753.         p->cyclic_temp_file = 1;
  2754.         c->sendfile = 0;

  2756.     } else {
  2757.         p->cyclic_temp_file = 0;
  2758.     }

  2760.     p->read_timeout = u->conf->read_timeout;
  2761.     p->send_timeout = clcf->send_timeout;
  2762.     p->send_lowat = clcf->send_lowat;

  2764.     p->length = -1;

  2766.     if (u->input_filter_init
  2767.         && u->input_filter_init(p->input_ctx) != NGX_OK)
  2768.     {
  2769.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2770.         return;
  2771.     }

  2773.     u->read_event_handler = ngx_http_upstream_process_upstream;
  2774.     r->write_event_handler = ngx_http_upstream_process_downstream;

  2776.     ngx_http_upstream_process_upstream(r, u);
  2777. }


  2780. static void
  2781. ‌ngx_http_upstream_upgrade(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2782. {
  2783.     int                        tcp_nodelay;
  2784.     ngx_connection_t          *c;
  2785.     ngx_http_core_loc_conf_t  *clcf;

  2787.     c = r->connection;
  2788.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2790.     /* TODO: prevent upgrade if not requested or not possible */

  2792.     r->keepalive = 0;
  2793.     c->log->action = "proxying upgraded connection";

  2795.     u->read_event_handler = ngx_http_upstream_upgraded_read_upstream;
  2796.     u->write_event_handler = ngx_http_upstream_upgraded_write_upstream;
  2797.     r->read_event_handler = ngx_http_upstream_upgraded_read_downstream;
  2798.     r->write_event_handler = ngx_http_upstream_upgraded_write_downstream;

  2800.     if (clcf->tcp_nodelay) {
  2801.         tcp_nodelay = 1;

  2803.         if (c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
  2804.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "tcp_nodelay");

  2806.             if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
  2807.                            (const void *) &tcp_nodelay, sizeof(int)) == -1)
  2808.             {
  2809.                 ngx_connection_error(c, ngx_socket_errno,
  2810.                                      "setsockopt(TCP_NODELAY) failed");
  2811.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2812.                 return;
  2813.             }

  2815.             c->tcp_nodelay = NGX_TCP_NODELAY_SET;
  2816.         }

  2818.         if (u->peer.connection->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
  2819.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, u->peer.connection->log, 0,
  2820.                            "tcp_nodelay");

  2822.             if (setsockopt(u->peer.connection->fd, IPPROTO_TCP, TCP_NODELAY,
  2823.                            (const void *) &tcp_nodelay, sizeof(int)) == -1)
  2824.             {
  2825.                 ngx_connection_error(u->peer.connection, ngx_socket_errno,
  2826.                                      "setsockopt(TCP_NODELAY) failed");
  2827.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2828.                 return;
  2829.             }

  2831.             u->peer.connection->tcp_nodelay = NGX_TCP_NODELAY_SET;
  2832.         }
  2833.     }

  2835.     if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  2836.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2837.         return;
  2838.     }

  2840.     if (u->peer.connection->read->ready
  2841.         || u->buffer.pos != u->buffer.last)
  2842.     {
  2843.         ngx_post_event(c->read, &ngx_posted_events);
  2844.         ngx_http_upstream_process_upgraded(r, 1, 1);
  2845.         return;
  2846.     }

  2848.     ngx_http_upstream_process_upgraded(r, 0, 1);
  2849. }


  2852. static void
  2853. ‌ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r)
  2854. {
  2855.     ngx_http_upstream_process_upgraded(r, 0, 0);
  2856. }


  2859. static void
  2860. ‌ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r)
  2861. {
  2862.     ngx_http_upstream_process_upgraded(r, 1, 1);
  2863. }


  2866. static void
  2867. ‌ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  2868.     ngx_http_upstream_t *u)
  2869. {
  2870.     ngx_http_upstream_process_upgraded(r, 1, 0);
  2871. }


  2874. static void
  2875. ‌ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  2876.     ngx_http_upstream_t *u)
  2877. {
  2878.     ngx_http_upstream_process_upgraded(r, 0, 1);
  2879. }


  2882. static void
  2883. ‌ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  2884.     ngx_uint_t from_upstream, ngx_uint_t do_write)
  2885. {
  2886.     size_t                     size;
  2887.     ssize_t                    n;
  2888.     ngx_buf_t                 *b;
  2889.     ngx_connection_t          *c, *downstream, *upstream, *dst, *src;
  2890.     ngx_http_upstream_t       *u;
  2891.     ngx_http_core_loc_conf_t  *clcf;

  2893.     c = r->connection;
  2894.     u = r->upstream;

  2896.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2897.                    "http upstream process upgraded, fu:%ui", from_upstream);

  2899.     downstream = c;
  2900.     upstream = u->peer.connection;

  2902.     if (downstream->write->timedout) {
  2903.         c->timedout = 1;
  2904.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  2905.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  2906.         return;
  2907.     }

  2909.     if (upstream->read->timedout || upstream->write->timedout) {
  2910.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  2911.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  2912.         return;
  2913.     }

  2915.     if (from_upstream) {
  2916.         src = upstream;
  2917.         dst = downstream;
  2918.         b = &u->buffer;

  2920.     } else {
  2921.         src = downstream;
  2922.         dst = upstream;
  2923.         b = &u->from_client;

  2925.         if (r->header_in->last > r->header_in->pos) {
  2926.             b = r->header_in;
  2927.             b->end = b->last;
  2928.             do_write = 1;
  2929.         }

  2931.         if (b->start == NULL) {
  2932.             b->start = ngx_palloc(r->pool, u->conf->buffer_size);
  2933.             if (b->start == NULL) {
  2934.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2935.                 return;
  2936.             }

  2938.             b->pos = b->start;
  2939.             b->last = b->start;
  2940.             b->end = b->start + u->conf->buffer_size;
  2941.             b->temporary = 1;
  2942.             b->tag = u->output.tag;
  2943.         }
  2944.     }

  2946.     for ( ;; ) {

  2948.         if (do_write) {

  2950.             size = b->last - b->pos;

  2952.             if (size && dst->write->ready) {

  2954.                 n = dst->send(dst, b->pos, size);

  2956.                 if (n == NGX_ERROR) {
  2957.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2958.                     return;
  2959.                 }

  2961.                 if (n > 0) {
  2962.                     b->pos += n;

  2964.                     if (b->pos == b->last) {
  2965.                         b->pos = b->start;
  2966.                         b->last = b->start;
  2967.                     }
  2968.                 }
  2969.             }
  2970.         }

  2972.         size = b->end - b->last;

  2974.         if (size && src->read->ready) {

  2976.             n = src->recv(src, b->last, size);

  2978.             if (n == NGX_AGAIN || n == 0) {
  2979.                 break;
  2980.             }

  2982.             if (n > 0) {
  2983.                 do_write = 1;
  2984.                 b->last += n;

  2986.                 continue;
  2987.             }

  2989.             if (n == NGX_ERROR) {
  2990.                 src->read->eof = 1;
  2991.             }
  2992.         }

  2994.         break;
  2995.     }

  2997.     if ((upstream->read->eof && u->buffer.pos == u->buffer.last)
  2998.         || (downstream->read->eof && u->from_client.pos == u->from_client.last)
  2999.         || (downstream->read->eof && upstream->read->eof))
  3000.     {
  3001.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3002.                        "http upstream upgraded done");
  3003.         ngx_http_upstream_finalize_request(r, u, 0);
  3004.         return;
  3005.     }

  3007.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3009.     if (ngx_handle_write_event(upstream->write, u->conf->send_lowat)
  3010.         != NGX_OK)
  3011.     {
  3012.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3013.         return;
  3014.     }

  3016.     if (upstream->write->active && !upstream->write->ready) {
  3017.         ngx_add_timer(upstream->write, u->conf->send_timeout);

  3019.     } else if (upstream->write->timer_set) {
  3020.         ngx_del_timer(upstream->write);
  3021.     }

  3023.     if (ngx_handle_read_event(upstream->read, 0) != NGX_OK) {
  3024.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3025.         return;
  3026.     }

  3028.     if (upstream->read->active && !upstream->read->ready) {
  3029.         ngx_add_timer(upstream->read, u->conf->read_timeout);

  3031.     } else if (upstream->read->timer_set) {
  3032.         ngx_del_timer(upstream->read);
  3033.     }

  3035.     if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3036.         != NGX_OK)
  3037.     {
  3038.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3039.         return;
  3040.     }

  3042.     if (ngx_handle_read_event(downstream->read, 0) != NGX_OK) {
  3043.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3044.         return;
  3045.     }

  3047.     if (downstream->write->active && !downstream->write->ready) {
  3048.         ngx_add_timer(downstream->write, clcf->send_timeout);

  3050.     } else if (downstream->write->timer_set) {
  3051.         ngx_del_timer(downstream->write);
  3052.     }
  3053. }


  3056. static void
  3057. ‌ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r)
  3058. {
  3059.     ngx_event_t          *wev;
  3060.     ngx_connection_t     *c;
  3061.     ngx_http_upstream_t  *u;

  3063.     c = r->connection;
  3064.     u = r->upstream;
  3065.     wev = c->write;

  3067.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3068.                    "http upstream process non buffered downstream");

  3070.     c->log->action = "sending to client";

  3072.     if (wev->timedout) {
  3073.         c->timedout = 1;
  3074.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3075.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3076.         return;
  3077.     }

  3079.     ngx_http_upstream_process_non_buffered_request(r, 1);
  3080. }


  3083. static void
  3084. ‌ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  3085.     ngx_http_upstream_t *u)
  3086. {
  3087.     ngx_connection_t  *c;

  3089.     c = u->peer.connection;

  3091.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3092.                    "http upstream process non buffered upstream");

  3094.     c->log->action = "reading upstream";

  3096.     if (c->read->timedout) {
  3097.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3098.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3099.         return;
  3100.     }

  3102.     ngx_http_upstream_process_non_buffered_request(r, 0);
  3103. }


  3106. static void
  3107. ‌ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  3108.     ngx_uint_t do_write)
  3109. {
  3110.     size_t                     size;
  3111.     ssize_t                    n;
  3112.     ngx_buf_t                 *b;
  3113.     ngx_int_t                  rc;
  3114.     ngx_connection_t          *downstream, *upstream;
  3115.     ngx_http_upstream_t       *u;
  3116.     ngx_http_core_loc_conf_t  *clcf;

  3118.     u = r->upstream;
  3119.     downstream = r->connection;
  3120.     upstream = u->peer.connection;

  3122.     b = &u->buffer;

  3124.     do_write = do_write || u->length == 0;

  3126.     for ( ;; ) {

  3128.         if (do_write) {

  3130.             if (u->out_bufs || u->busy_bufs) {
  3131.                 rc = ngx_http_output_filter(r, u->out_bufs);

  3133.                 if (rc == NGX_ERROR) {
  3134.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3135.                     return;
  3136.                 }

  3138.                 ngx_chain_update_chains(r->pool, &u->free_bufs, &u->busy_bufs,
  3139.                                         &u->out_bufs, u->output.tag);
  3140.             }

  3142.             if (u->busy_bufs == NULL) {

  3144.                 if (u->length == 0
  3145.                     || (upstream->read->eof && u->length == -1))
  3146.                 {
  3147.                     ngx_http_upstream_finalize_request(r, u, 0);
  3148.                     return;
  3149.                 }

  3151.                 if (upstream->read->eof) {
  3152.                     ngx_log_error(NGX_LOG_ERR, upstream->log, 0,
  3153.                                   "upstream prematurely closed connection");

  3155.                     ngx_http_upstream_finalize_request(r, u,
  3156.                                                        NGX_HTTP_BAD_GATEWAY);
  3157.                     return;
  3158.                 }

  3160.                 if (upstream->read->error) {
  3161.                     ngx_http_upstream_finalize_request(r, u,
  3162.                                                        NGX_HTTP_BAD_GATEWAY);
  3163.                     return;
  3164.                 }

  3166.                 b->pos = b->start;
  3167.                 b->last = b->start;
  3168.             }
  3169.         }

  3171.         size = b->end - b->last;

  3173.         if (size && upstream->read->ready) {

  3175.             n = upstream->recv(upstream, b->last, size);

  3177.             if (n == NGX_AGAIN) {
  3178.                 break;
  3179.             }

  3181.             if (n > 0) {
  3182.                 u->state->response_length += n;

  3184.                 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  3185.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3186.                     return;
  3187.                 }
  3188.             }

  3190.             do_write = 1;

  3192.             continue;
  3193.         }

  3195.         break;
  3196.     }

  3198.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3200.     if (downstream->data == r) {
  3201.         if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3202.             != NGX_OK)
  3203.         {
  3204.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3205.             return;
  3206.         }
  3207.     }

  3209.     if (downstream->write->active && !downstream->write->ready) {
  3210.         ngx_add_timer(downstream->write, clcf->send_timeout);

  3212.     } else if (downstream->write->timer_set) {
  3213.         ngx_del_timer(downstream->write);
  3214.     }

  3216.     if (ngx_handle_read_event(upstream->read, 0) != NGX_OK) {
  3217.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3218.         return;
  3219.     }

  3221.     if (upstream->read->active && !upstream->read->ready) {
  3222.         ngx_add_timer(upstream->read, u->conf->read_timeout);

  3224.     } else if (upstream->read->timer_set) {
  3225.         ngx_del_timer(upstream->read);
  3226.     }
  3227. }


  3230. static ngx_int_t
  3231. ‌ngx_http_upstream_non_buffered_filter_init(void *data)
  3232. {
  3233.     return NGX_OK;
  3234. }


  3237. static ngx_int_t
  3238. ‌ngx_http_upstream_non_buffered_filter(void *data, ssize_t bytes)
  3239. {
  3240.     ngx_http_request_t  *r = data;

  3242.     ngx_buf_t            *b;
  3243.     ngx_chain_t          *cl, **ll;
  3244.     ngx_http_upstream_t  *u;

  3246.     u = r->upstream;

  3248.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  3249.         ll = &cl->next;
  3250.     }

  3252.     cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  3253.     if (cl == NULL) {
  3254.         return NGX_ERROR;
  3255.     }

  3257.     *ll = cl;

  3259.     cl->buf->flush = 1;
  3260.     cl->buf->memory = 1;

  3262.     b = &u->buffer;

  3264.     cl->buf->pos = b->last;
  3265.     b->last += bytes;
  3266.     cl->buf->last = b->last;
  3267.     cl->buf->tag = u->output.tag;

  3269.     if (u->length == -1) {
  3270.         return NGX_OK;
  3271.     }

  3273.     u->length -= bytes;

  3275.     return NGX_OK;
  3276. }


  3279. static void
  3280. ‌ngx_http_upstream_process_downstream(ngx_http_request_t *r)
  3281. {
  3282.     ngx_event_t          *wev;
  3283.     ngx_connection_t     *c;
  3284.     ngx_event_pipe_t     *p;
  3285.     ngx_http_upstream_t  *u;

  3287.     c = r->connection;
  3288.     u = r->upstream;
  3289.     p = u->pipe;
  3290.     wev = c->write;

  3292.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3293.                    "http upstream process downstream");

  3295.     c->log->action = "sending to client";

  3297.     if (wev->timedout) {

  3299.         if (wev->delayed) {

  3301.             wev->timedout = 0;
  3302.             wev->delayed = 0;

  3304.             if (!wev->ready) {
  3305.                 ngx_add_timer(wev, p->send_timeout);

  3307.                 if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
  3308.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3309.                 }

  3311.                 return;
  3312.             }

  3314.             if (ngx_event_pipe(p, wev->write) == NGX_ABORT) {
  3315.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3316.                 return;
  3317.             }

  3319.         } else {
  3320.             p->downstream_error = 1;
  3321.             c->timedout = 1;
  3322.             ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3323.         }

  3325.     } else {

  3327.         if (wev->delayed) {

  3329.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3330.                            "http downstream delayed");

  3332.             if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
  3333.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3334.             }

  3336.             return;
  3337.         }

  3339.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  3340.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3341.             return;
  3342.         }
  3343.     }

  3345.     ngx_http_upstream_process_request(r);
  3346. }


  3349. static void
  3350. ‌ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  3351.     ngx_http_upstream_t *u)
  3352. {
  3353.     ngx_event_t       *rev;
  3354.     ngx_event_pipe_t  *p;
  3355.     ngx_connection_t  *c;

  3357.     c = u->peer.connection;
  3358.     p = u->pipe;
  3359.     rev = c->read;

  3361.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3362.                    "http upstream process upstream");

  3364.     c->log->action = "reading upstream";

  3366.     if (rev->timedout) {

  3368.         if (rev->delayed) {

  3370.             rev->timedout = 0;
  3371.             rev->delayed = 0;

  3373.             if (!rev->ready) {
  3374.                 ngx_add_timer(rev, p->read_timeout);

  3376.                 if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3377.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3378.                 }

  3380.                 return;
  3381.             }

  3383.             if (ngx_event_pipe(p, 0) == NGX_ABORT) {
  3384.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3385.                 return;
  3386.             }

  3388.         } else {
  3389.             p->upstream_error = 1;
  3390.             ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3391.         }

  3393.     } else {

  3395.         if (rev->delayed) {

  3397.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3398.                            "http upstream delayed");

  3400.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  3401.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3402.             }

  3404.             return;
  3405.         }

  3407.         if (ngx_event_pipe(p, 0) == NGX_ABORT) {
  3408.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3409.             return;
  3410.         }
  3411.     }

  3413.     ngx_http_upstream_process_request(r);
  3414. }


  3417. static void
  3418. ‌ngx_http_upstream_process_request(ngx_http_request_t *r)
  3419. {
  3420.     ngx_temp_file_t      *tf;
  3421.     ngx_event_pipe_t     *p;
  3422.     ngx_http_upstream_t  *u;

  3424.     u = r->upstream;
  3425.     p = u->pipe;

  3427.     if (u->peer.connection) {

  3429.         if (u->store) {

  3431.             if (p->upstream_eof || p->upstream_done) {

  3433.                 tf = p->temp_file;

  3435.                 if (u->headers_in.status_n == NGX_HTTP_OK
  3436.                     && (p->upstream_done || p->length == -1)
  3437.                     && (u->headers_in.content_length_n == -1
  3438.                         || u->headers_in.content_length_n == tf->offset))
  3439.                 {
  3440.                     ngx_http_upstream_store(r, u);
  3441.                 }
  3442.             }
  3443.         }

  3445. #if (NGX_HTTP_CACHE)

  3447.         if (u->cacheable) {

  3449.             if (p->upstream_done) {
  3450.                 ngx_http_file_cache_update(r, p->temp_file);

  3452.             } else if (p->upstream_eof) {

  3454.                 tf = p->temp_file;

  3456.                 if (p->length == -1
  3457.                     && (u->headers_in.content_length_n == -1
  3458.                         || u->headers_in.content_length_n
  3459.                            == tf->offset - (off_t) r->cache->body_start))
  3460.                 {
  3461.                     ngx_http_file_cache_update(r, tf);

  3463.                 } else {
  3464.                     ngx_http_file_cache_free(r->cache, tf);
  3465.                 }

  3467.             } else if (p->upstream_error) {
  3468.                 ngx_http_file_cache_free(r->cache, p->temp_file);
  3469.             }
  3470.         }

  3472. #endif

  3474.         if (p->upstream_done || p->upstream_eof || p->upstream_error) {
  3475.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3476.                            "http upstream exit: %p", p->out);

  3478.             if (p->upstream_done
  3479.                 || (p->upstream_eof && p->length == -1))
  3480.             {
  3481.                 ngx_http_upstream_finalize_request(r, u, 0);
  3482.                 return;
  3483.             }

  3485.             if (p->upstream_eof) {
  3486.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3487.                               "upstream prematurely closed connection");
  3488.             }

  3490.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  3491.             return;
  3492.         }
  3493.     }

  3495.     if (p->downstream_error) {
  3496.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3497.                        "http upstream downstream error");

  3499.         if (!u->cacheable && !u->store && u->peer.connection) {
  3500.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3501.         }
  3502.     }
  3503. }


  3506. static void
  3507. ‌ngx_http_upstream_store(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3508. {
  3509.     size_t                  root;
  3510.     time_t                  lm;
  3511.     ngx_str_t               path;
  3512.     ngx_temp_file_t        *tf;
  3513.     ngx_ext_rename_file_t   ext;

  3515.     tf = u->pipe->temp_file;

  3517.     if (tf->file.fd == NGX_INVALID_FILE) {

  3519.         /* create file for empty 200 response */

  3521.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  3522.         if (tf == NULL) {
  3523.             return;
  3524.         }

  3526.         tf->file.fd = NGX_INVALID_FILE;
  3527.         tf->file.log = r->connection->log;
  3528.         tf->path = u->conf->temp_path;
  3529.         tf->pool = r->pool;
  3530.         tf->persistent = 1;

  3532.         if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  3533.                                  tf->persistent, tf->clean, tf->access)
  3534.             != NGX_OK)
  3535.         {
  3536.             return;
  3537.         }

  3539.         u->pipe->temp_file = tf;
  3540.     }

  3542.     ext.access = u->conf->store_access;
  3543.     ext.path_access = u->conf->store_access;
  3544.     ext.time = -1;
  3545.     ext.create_path = 1;
  3546.     ext.delete_file = 1;
  3547.     ext.log = r->connection->log;

  3549.     if (u->headers_in.last_modified) {

  3551.         lm = ngx_http_parse_time(u->headers_in.last_modified->value.data,
  3552.                                  u->headers_in.last_modified->value.len);

  3554.         if (lm != NGX_ERROR) {
  3555.             ext.time = lm;
  3556.             ext.fd = tf->file.fd;
  3557.         }
  3558.     }

  3560.     if (u->conf->store_lengths == NULL) {

  3562.         if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  3563.             return;
  3564.         }

  3566.     } else {
  3567.         if (ngx_http_script_run(r, &path, u->conf->store_lengths->elts, 0,
  3568.                                 u->conf->store_values->elts)
  3569.             == NULL)
  3570.         {
  3571.             return;
  3572.         }
  3573.     }

  3575.     path.len--;

  3577.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3578.                    "upstream stores \"%s\" to \"%s\"",
  3579.                    tf->file.name.data, path.data);

  3581.     (void) ngx_ext_rename_file(&tf->file.name, &path, &ext);

  3583.     u->store = 0;
  3584. }


  3587. static void
  3588. ‌ngx_http_upstream_dummy_handler(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3589. {
  3590.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3591.                    "http upstream dummy handler");
  3592. }


  3595. static void
  3596. ‌ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
  3597.     ngx_uint_t ft_type)
  3598. {
  3599.     ngx_msec_t  timeout;
  3600.     ngx_uint_t  status, state;

  3602.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3603.                    "http next upstream, %xi", ft_type);

  3605.     if (u->peer.sockaddr) {

  3607.         if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_403
  3608.             || ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404)
  3609.         {
  3610.             state = NGX_PEER_NEXT;

  3612.         } else {
  3613.             state = NGX_PEER_FAILED;
  3614.         }

  3616.         u->peer.free(&u->peer, u->peer.data, state);
  3617.         u->peer.sockaddr = NULL;
  3618.     }

  3620.     if (ft_type == NGX_HTTP_UPSTREAM_FT_TIMEOUT) {
  3621.         ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ETIMEDOUT,
  3622.                       "upstream timed out");
  3623.     }

  3625.     if (u->peer.cached && ft_type == NGX_HTTP_UPSTREAM_FT_ERROR) {
  3626.         status = 0;

  3628.         /* TODO: inform balancer instead */

  3630.         u->peer.tries++;

  3632.     } else {
  3633.         switch (ft_type) {

  3635.         case NGX_HTTP_UPSTREAM_FT_TIMEOUT:
  3636.             status = NGX_HTTP_GATEWAY_TIME_OUT;
  3637.             break;

  3639.         case NGX_HTTP_UPSTREAM_FT_HTTP_500:
  3640.             status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  3641.             break;

  3643.         case NGX_HTTP_UPSTREAM_FT_HTTP_403:
  3644.             status = NGX_HTTP_FORBIDDEN;
  3645.             break;

  3647.         case NGX_HTTP_UPSTREAM_FT_HTTP_404:
  3648.             status = NGX_HTTP_NOT_FOUND;
  3649.             break;

  3651.         /*
  3652.          * NGX_HTTP_UPSTREAM_FT_BUSY_LOCK and NGX_HTTP_UPSTREAM_FT_MAX_WAITING
  3653.          * never reach here
  3654.          */

  3656.         default:
  3657.             status = NGX_HTTP_BAD_GATEWAY;
  3658.         }
  3659.     }

  3661.     if (r->connection->error) {
  3662.         ngx_http_upstream_finalize_request(r, u,
  3663.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  3664.         return;
  3665.     }

  3667.     if (status) {
  3668.         u->state->status = status;
  3669.         timeout = u->conf->next_upstream_timeout;

  3671.         if (u->peer.tries == 0
  3672.             || !(u->conf->next_upstream & ft_type)
  3673.             || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  3674.         {
  3675. #if (NGX_HTTP_CACHE)

  3677.             if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  3678.                 && (u->conf->cache_use_stale & ft_type))
  3679.             {
  3680.                 ngx_int_t  rc;

  3682.                 rc = u->reinit_request(r);

  3684.                 if (rc == NGX_OK) {
  3685.                     u->cache_status = NGX_HTTP_CACHE_STALE;
  3686.                     rc = ngx_http_upstream_cache_send(r, u);
  3687.                 }

  3689.                 ngx_http_upstream_finalize_request(r, u, rc);
  3690.                 return;
  3691.             }
  3692. #endif

  3694.             ngx_http_upstream_finalize_request(r, u, status);
  3695.             return;
  3696.         }
  3697.     }

  3699.     if (u->peer.connection) {
  3700.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3701.                        "close http upstream connection: %d",
  3702.                        u->peer.connection->fd);
  3703. #if (NGX_HTTP_SSL)

  3705.         if (u->peer.connection->ssl) {
  3706.             u->peer.connection->ssl->no_wait_shutdown = 1;
  3707.             u->peer.connection->ssl->no_send_shutdown = 1;

  3709.             (void) ngx_ssl_shutdown(u->peer.connection);
  3710.         }
  3711. #endif

  3713.         if (u->peer.connection->pool) {
  3714.             ngx_destroy_pool(u->peer.connection->pool);
  3715.         }

  3717.         ngx_close_connection(u->peer.connection);
  3718.         u->peer.connection = NULL;
  3719.     }

  3721.     ngx_http_upstream_connect(r, u);
  3722. }


  3725. static void
  3726. ‌ngx_http_upstream_cleanup(void *data)
  3727. {
  3728.     ngx_http_request_t *r = data;

  3730.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3731.                    "cleanup http upstream request: \"%V\"", &r->uri);

  3733.     ngx_http_upstream_finalize_request(r, r->upstream, NGX_DONE);
  3734. }


  3737. static void
  3738. ‌ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  3739.     ngx_http_upstream_t *u, ngx_int_t rc)
  3740. {
  3741.     ngx_uint_t   flush;
  3742.     ngx_time_t  *tp;

  3744.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3745.                    "finalize http upstream request: %i", rc);

  3747.     if (u->cleanup) {
  3748.         *u->cleanup = NULL;
  3749.         u->cleanup = NULL;
  3750.     }

  3752.     if (u->resolved && u->resolved->ctx) {
  3753.         ngx_resolve_name_done(u->resolved->ctx);
  3754.         u->resolved->ctx = NULL;
  3755.     }

  3757.     if (u->state && u->state->response_sec) {
  3758.         tp = ngx_timeofday();
  3759.         u->state->response_sec = tp->sec - u->state->response_sec;
  3760.         u->state->response_msec = tp->msec - u->state->response_msec;

  3762.         if (u->pipe && u->pipe->read_length) {
  3763.             u->state->response_length = u->pipe->read_length;
  3764.         }
  3765.     }

  3767.     u->finalize_request(r, rc);

  3769.     if (u->peer.free && u->peer.sockaddr) {
  3770.         u->peer.free(&u->peer, u->peer.data, 0);
  3771.         u->peer.sockaddr = NULL;
  3772.     }

  3774.     if (u->peer.connection) {

  3776. #if (NGX_HTTP_SSL)

  3778.         /* TODO: do not shutdown persistent connection */

  3780.         if (u->peer.connection->ssl) {

  3782.             /*
  3783.              * We send the "close notify" shutdown alert to the upstream only
  3784.              * and do not wait its "close notify" shutdown alert.
  3785.              * It is acceptable according to the TLS standard.
  3786.              */

  3788.             u->peer.connection->ssl->no_wait_shutdown = 1;

  3790.             (void) ngx_ssl_shutdown(u->peer.connection);
  3791.         }
  3792. #endif

  3794.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3795.                        "close http upstream connection: %d",
  3796.                        u->peer.connection->fd);

  3798.         if (u->peer.connection->pool) {
  3799.             ngx_destroy_pool(u->peer.connection->pool);
  3800.         }

  3802.         ngx_close_connection(u->peer.connection);
  3803.     }

  3805.     u->peer.connection = NULL;

  3807.     if (u->pipe && u->pipe->temp_file) {
  3808.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  3809.                        "http upstream temp fd: %d",
  3810.                        u->pipe->temp_file->file.fd);
  3811.     }

  3813.     if (u->store && u->pipe && u->pipe->temp_file
  3814.         && u->pipe->temp_file->file.fd != NGX_INVALID_FILE)
  3815.     {
  3816.         if (ngx_delete_file(u->pipe->temp_file->file.name.data)
  3817.             == NGX_FILE_ERROR)
  3818.         {
  3819.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  3820.                           ngx_delete_file_n " \"%s\" failed",
  3821.                           u->pipe->temp_file->file.name.data);
  3822.         }
  3823.     }

  3825. #if (NGX_HTTP_CACHE)

  3827.     if (r->cache) {

  3829.         if (u->cacheable) {

  3831.             if (rc == NGX_HTTP_BAD_GATEWAY || rc == NGX_HTTP_GATEWAY_TIME_OUT) {
  3832.                 time_t  valid;

  3834.                 valid = ngx_http_file_cache_valid(u->conf->cache_valid, rc);

  3836.                 if (valid) {
  3837.                     r->cache->valid_sec = ngx_time() + valid;
  3838.                     r->cache->error = rc;
  3839.                 }
  3840.             }
  3841.         }

  3843.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3844.     }

  3846. #endif

  3848.     if (r->subrequest_in_memory
  3849.         && u->headers_in.status_n >= NGX_HTTP_SPECIAL_RESPONSE)
  3850.     {
  3851.         u->buffer.last = u->buffer.pos;
  3852.     }

  3854.     if (rc == NGX_DECLINED) {
  3855.         return;
  3856.     }

  3858.     r->connection->log->action = "sending to client";

  3860.     if (!u->header_sent
  3861.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  3862.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST)
  3863.     {
  3864.         ngx_http_finalize_request(r, rc);
  3865.         return;
  3866.     }

  3868.     flush = 0;

  3870.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  3871.         rc = NGX_ERROR;
  3872.         flush = 1;
  3873.     }

  3875.     if (r->header_only) {
  3876.         ngx_http_finalize_request(r, rc);
  3877.         return;
  3878.     }

  3880.     if (rc == 0) {
  3881.         rc = ngx_http_send_special(r, NGX_HTTP_LAST);

  3883.     } else if (flush) {
  3884.         r->keepalive = 0;
  3885.         rc = ngx_http_send_special(r, NGX_HTTP_FLUSH);
  3886.     }

  3888.     ngx_http_finalize_request(r, rc);
  3889. }


  3892. static ngx_int_t
  3893. ‌ngx_http_upstream_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  3894.     ngx_uint_t offset)
  3895. {
  3896.     ngx_table_elt_t  **ph;

  3898.     ph = (ngx_table_elt_t **) ((char *) &r->upstream->headers_in + offset);

  3900.     if (*ph == NULL) {
  3901.         *ph = h;
  3902.     }

  3904.     return NGX_OK;
  3905. }


  3908. static ngx_int_t
  3909. ‌ngx_http_upstream_ignore_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  3910.     ngx_uint_t offset)
  3911. {
  3912.     return NGX_OK;
  3913. }


  3916. static ngx_int_t
  3917. ‌ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  3918.     ngx_table_elt_t *h, ngx_uint_t offset)
  3919. {
  3920.     ngx_http_upstream_t  *u;

  3922.     u = r->upstream;

  3924.     u->headers_in.content_length = h;
  3925.     u->headers_in.content_length_n = ngx_atoof(h->value.data, h->value.len);

  3927.     return NGX_OK;
  3928. }


  3931. static ngx_int_t
  3932. ‌ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  3933.     ngx_table_elt_t *h, ngx_uint_t offset)
  3934. {
  3935.     ngx_http_upstream_t  *u;

  3937.     u = r->upstream;

  3939.     u->headers_in.last_modified = h;

  3941. #if (NGX_HTTP_CACHE)

  3943.     if (u->cacheable) {
  3944.         u->headers_in.last_modified_time = ngx_http_parse_time(h->value.data,
  3945.                                                                h->value.len);
  3946.     }

  3948. #endif

  3950.     return NGX_OK;
  3951. }


  3954. static ngx_int_t
  3955. ‌ngx_http_upstream_process_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  3956.     ngx_uint_t offset)
  3957. {
  3958.     ngx_array_t           *pa;
  3959.     ngx_table_elt_t      **ph;
  3960.     ngx_http_upstream_t   *u;

  3962.     u = r->upstream;
  3963.     pa = &u->headers_in.cookies;

  3965.     if (pa->elts == NULL) {
  3966.         if (ngx_array_init(pa, r->pool, 1, sizeof(ngx_table_elt_t *)) != NGX_OK)
  3967.         {
  3968.             return NGX_ERROR;
  3969.         }
  3970.     }

  3972.     ph = ngx_array_push(pa);
  3973.     if (ph == NULL) {
  3974.         return NGX_ERROR;
  3975.     }

  3977.     *ph = h;

  3979. #if (NGX_HTTP_CACHE)
  3980.     if (!(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_SET_COOKIE)) {
  3981.         u->cacheable = 0;
  3982.     }
  3983. #endif

  3985.     return NGX_OK;
  3986. }


  3989. static ngx_int_t
  3990. ‌ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  3991.     ngx_table_elt_t *h, ngx_uint_t offset)
  3992. {
  3993.     ngx_array_t          *pa;
  3994.     ngx_table_elt_t     **ph;
  3995.     ngx_http_upstream_t  *u;

  3997.     u = r->upstream;
  3998.     pa = &u->headers_in.cache_control;

  4000.     if (pa->elts == NULL) {
  4001.        if (ngx_array_init(pa, r->pool, 2, sizeof(ngx_table_elt_t *)) != NGX_OK)
  4002.        {
  4003.            return NGX_ERROR;
  4004.        }
  4005.     }

  4007.     ph = ngx_array_push(pa);
  4008.     if (ph == NULL) {
  4009.         return NGX_ERROR;
  4010.     }

  4012.     *ph = h;

  4014. #if (NGX_HTTP_CACHE)
  4015.     {
  4016.     u_char     *p, *start, *last;
  4017.     ngx_int_t   n;

  4019.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL) {
  4020.         return NGX_OK;
  4021.     }

  4023.     if (r->cache == NULL) {
  4024.         return NGX_OK;
  4025.     }

  4027.     if (r->cache->valid_sec != 0 && u->headers_in.x_accel_expires != NULL) {
  4028.         return NGX_OK;
  4029.     }

  4031.     start = h->value.data;
  4032.     last = start + h->value.len;

  4034.     if (ngx_strlcasestrn(start, last, (u_char *) "no-cache", 8 - 1) != NULL
  4035.         || ngx_strlcasestrn(start, last, (u_char *) "no-store", 8 - 1) != NULL
  4036.         || ngx_strlcasestrn(start, last, (u_char *) "private", 7 - 1) != NULL)
  4037.     {
  4038.         u->cacheable = 0;
  4039.         return NGX_OK;
  4040.     }

  4042.     p = ngx_strlcasestrn(start, last, (u_char *) "s-maxage=", 9 - 1);
  4043.     offset = 9;

  4045.     if (p == NULL) {
  4046.         p = ngx_strlcasestrn(start, last, (u_char *) "max-age=", 8 - 1);
  4047.         offset = 8;
  4048.     }

  4050.     if (p == NULL) {
  4051.         return NGX_OK;
  4052.     }

  4054.     n = 0;

  4056.     for (p += offset; p < last; p++) {
  4057.         if (*p == ',' || *p == ';' || *p == ' ') {
  4058.             break;
  4059.         }

  4061.         if (*p >= '0' && *p <= '9') {
  4062.             n = n * 10 + *p - '0';
  4063.             continue;
  4064.         }

  4066.         u->cacheable = 0;
  4067.         return NGX_OK;
  4068.     }

  4070.     if (n == 0) {
  4071.         u->cacheable = 0;
  4072.         return NGX_OK;
  4073.     }

  4075.     r->cache->valid_sec = ngx_time() + n;
  4076.     }
  4077. #endif

  4079.     return NGX_OK;
  4080. }


  4083. static ngx_int_t
  4084. ‌ngx_http_upstream_process_expires(ngx_http_request_t *r, ngx_table_elt_t *h,
  4085.     ngx_uint_t offset)
  4086. {
  4087.     ngx_http_upstream_t  *u;

  4089.     u = r->upstream;
  4090.     u->headers_in.expires = h;

  4092. #if (NGX_HTTP_CACHE)
  4093.     {
  4094.     time_t  expires;

  4096.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_EXPIRES) {
  4097.         return NGX_OK;
  4098.     }

  4100.     if (r->cache == NULL) {
  4101.         return NGX_OK;
  4102.     }

  4104.     if (r->cache->valid_sec != 0) {
  4105.         return NGX_OK;
  4106.     }

  4108.     expires = ngx_http_parse_time(h->value.data, h->value.len);

  4110.     if (expires == NGX_ERROR || expires < ngx_time()) {
  4111.         u->cacheable = 0;
  4112.         return NGX_OK;
  4113.     }

  4115.     r->cache->valid_sec = expires;
  4116.     }
  4117. #endif

  4119.     return NGX_OK;
  4120. }


  4123. static ngx_int_t
  4124. ‌ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  4125.     ngx_table_elt_t *h, ngx_uint_t offset)
  4126. {
  4127.     ngx_http_upstream_t  *u;

  4129.     u = r->upstream;
  4130.     u->headers_in.x_accel_expires = h;

  4132. #if (NGX_HTTP_CACHE)
  4133.     {
  4134.     u_char     *p;
  4135.     size_t      len;
  4136.     ngx_int_t   n;

  4138.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES) {
  4139.         return NGX_OK;
  4140.     }

  4142.     if (r->cache == NULL) {
  4143.         return NGX_OK;
  4144.     }

  4146.     len = h->value.len;
  4147.     p = h->value.data;

  4149.     if (p[0] != '@') {
  4150.         n = ngx_atoi(p, len);

  4152.         switch (n) {
  4153.         case 0:
  4154.             u->cacheable = 0;
  4155.             /* fall through */

  4157.         case NGX_ERROR:
  4158.             return NGX_OK;

  4160.         default:
  4161.             r->cache->valid_sec = ngx_time() + n;
  4162.             return NGX_OK;
  4163.         }
  4164.     }

  4166.     p++;
  4167.     len--;

  4169.     n = ngx_atoi(p, len);

  4171.     if (n != NGX_ERROR) {
  4172.         r->cache->valid_sec = n;
  4173.     }
  4174.     }
  4175. #endif

  4177.     return NGX_OK;
  4178. }


  4181. static ngx_int_t
  4182. ‌ngx_http_upstream_process_limit_rate(ngx_http_request_t *r, ngx_table_elt_t *h,
  4183.     ngx_uint_t offset)
  4184. {
  4185.     ngx_int_t             n;
  4186.     ngx_http_upstream_t  *u;

  4188.     u = r->upstream;
  4189.     u->headers_in.x_accel_limit_rate = h;

  4191.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE) {
  4192.         return NGX_OK;
  4193.     }

  4195.     n = ngx_atoi(h->value.data, h->value.len);

  4197.     if (n != NGX_ERROR) {
  4198.         r->limit_rate = (size_t) n;
  4199.     }

  4201.     return NGX_OK;
  4202. }


  4205. static ngx_int_t
  4206. ‌ngx_http_upstream_process_buffering(ngx_http_request_t *r, ngx_table_elt_t *h,
  4207.     ngx_uint_t offset)
  4208. {
  4209.     u_char                c0, c1, c2;
  4210.     ngx_http_upstream_t  *u;

  4212.     u = r->upstream;

  4214.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING) {
  4215.         return NGX_OK;
  4216.     }

  4218.     if (u->conf->change_buffering) {

  4220.         if (h->value.len == 2) {
  4221.             c0 = ngx_tolower(h->value.data[0]);
  4222.             c1 = ngx_tolower(h->value.data[1]);

  4224.             if (c0 == 'n' && c1 == 'o') {
  4225.                 u->buffering = 0;
  4226.             }

  4228.         } else if (h->value.len == 3) {
  4229.             c0 = ngx_tolower(h->value.data[0]);
  4230.             c1 = ngx_tolower(h->value.data[1]);
  4231.             c2 = ngx_tolower(h->value.data[2]);

  4233.             if (c0 == 'y' && c1 == 'e' && c2 == 's') {
  4234.                 u->buffering = 1;
  4235.             }
  4236.         }
  4237.     }

  4239.     return NGX_OK;
  4240. }


  4243. static ngx_int_t
  4244. ‌ngx_http_upstream_process_charset(ngx_http_request_t *r, ngx_table_elt_t *h,
  4245.     ngx_uint_t offset)
  4246. {
  4247.     if (r->upstream->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_CHARSET) {
  4248.         return NGX_OK;
  4249.     }

  4251.     r->headers_out.override_charset = &h->value;

  4253.     return NGX_OK;
  4254. }


  4257. static ngx_int_t
  4258. ‌ngx_http_upstream_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  4259.     ngx_uint_t offset)
  4260. {
  4261.     r->upstream->headers_in.connection = h;

  4263.     if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
  4264.                          (u_char *) "close", 5 - 1)
  4265.         != NULL)
  4266.     {
  4267.         r->upstream->headers_in.connection_close = 1;
  4268.     }

  4270.     return NGX_OK;
  4271. }


  4274. static ngx_int_t
  4275. ‌ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  4276.     ngx_table_elt_t *h, ngx_uint_t offset)
  4277. {
  4278.     r->upstream->headers_in.transfer_encoding = h;

  4280.     if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
  4281.                          (u_char *) "chunked", 7 - 1)
  4282.         != NULL)
  4283.     {
  4284.         r->upstream->headers_in.chunked = 1;
  4285.     }

  4287.     return NGX_OK;
  4288. }


  4291. static ngx_int_t
  4292. ‌ngx_http_upstream_process_vary(ngx_http_request_t *r,
  4293.     ngx_table_elt_t *h, ngx_uint_t offset)
  4294. {
  4295.     ngx_http_upstream_t  *u;

  4297.     u = r->upstream;
  4298.     u->headers_in.vary = h;

  4300. #if (NGX_HTTP_CACHE)

  4302.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_VARY) {
  4303.         return NGX_OK;
  4304.     }

  4306.     if (r->cache == NULL) {
  4307.         return NGX_OK;
  4308.     }

  4310.     if (h->value.len > NGX_HTTP_CACHE_VARY_LEN
  4311.         || (h->value.len == 1 && h->value.data[0] == '*'))
  4312.     {
  4313.         u->cacheable = 0;
  4314.     }

  4316.     r->cache->vary = h->value;

  4318. #endif

  4320.     return NGX_OK;
  4321. }


  4324. static ngx_int_t
  4325. ‌ngx_http_upstream_copy_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4326.     ngx_uint_t offset)
  4327. {
  4328.     ngx_table_elt_t  *ho, **ph;

  4330.     ho = ngx_list_push(&r->headers_out.headers);
  4331.     if (ho == NULL) {
  4332.         return NGX_ERROR;
  4333.     }

  4335.     *ho = *h;

  4337.     if (offset) {
  4338.         ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);
  4339.         *ph = ho;
  4340.     }

  4342.     return NGX_OK;
  4343. }


  4346. static ngx_int_t
  4347. ‌ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  4348.     ngx_table_elt_t *h, ngx_uint_t offset)
  4349. {
  4350.     ngx_array_t      *pa;
  4351.     ngx_table_elt_t  *ho, **ph;

  4353.     pa = (ngx_array_t *) ((char *) &r->headers_out + offset);

  4355.     if (pa->elts == NULL) {
  4356.         if (ngx_array_init(pa, r->pool, 2, sizeof(ngx_table_elt_t *)) != NGX_OK)
  4357.         {
  4358.             return NGX_ERROR;
  4359.         }
  4360.     }

  4362.     ph = ngx_array_push(pa);
  4363.     if (ph == NULL) {
  4364.         return NGX_ERROR;
  4365.     }

  4367.     ho = ngx_list_push(&r->headers_out.headers);
  4368.     if (ho == NULL) {
  4369.         return NGX_ERROR;
  4370.     }

  4372.     *ho = *h;
  4373.     *ph = ho;

  4375.     return NGX_OK;
  4376. }


  4379. static ngx_int_t
  4380. ‌ngx_http_upstream_copy_content_type(ngx_http_request_t *r, ngx_table_elt_t *h,
  4381.     ngx_uint_t offset)
  4382. {
  4383.     u_char  *p, *last;

  4385.     r->headers_out.content_type_len = h->value.len;
  4386.     r->headers_out.content_type = h->value;
  4387.     r->headers_out.content_type_lowcase = NULL;

  4389.     for (p = h->value.data; *p; p++) {

  4391.         if (*p != ';') {
  4392.             continue;
  4393.         }

  4395.         last = p;

  4397.         while (*++p == ' ') { /* void */ }

  4399.         if (*p == '\0') {
  4400.             return NGX_OK;
  4401.         }

  4403.         if (ngx_strncasecmp(p, (u_char *) "charset=", 8) != 0) {
  4404.             continue;
  4405.         }

  4407.         p += 8;

  4409.         r->headers_out.content_type_len = last - h->value.data;

  4411.         if (*p == '"') {
  4412.             p++;
  4413.         }

  4415.         last = h->value.data + h->value.len;

  4417.         if (*(last - 1) == '"') {
  4418.             last--;
  4419.         }

  4421.         r->headers_out.charset.len = last - p;
  4422.         r->headers_out.charset.data = p;

  4424.         return NGX_OK;
  4425.     }

  4427.     return NGX_OK;
  4428. }


  4431. static ngx_int_t
  4432. ‌ngx_http_upstream_copy_last_modified(ngx_http_request_t *r, ngx_table_elt_t *h,
  4433.     ngx_uint_t offset)
  4434. {
  4435.     ngx_table_elt_t  *ho;

  4437.     ho = ngx_list_push(&r->headers_out.headers);
  4438.     if (ho == NULL) {
  4439.         return NGX_ERROR;
  4440.     }

  4442.     *ho = *h;

  4444.     r->headers_out.last_modified = ho;

  4446. #if (NGX_HTTP_CACHE)

  4448.     if (r->upstream->cacheable) {
  4449.         r->headers_out.last_modified_time =
  4450.                                     r->upstream->headers_in.last_modified_time;
  4451.     }

  4453. #endif

  4455.     return NGX_OK;
  4456. }


  4459. static ngx_int_t
  4460. ‌ngx_http_upstream_rewrite_location(ngx_http_request_t *r, ngx_table_elt_t *h,
  4461.     ngx_uint_t offset)
  4462. {
  4463.     ngx_int_t         rc;
  4464.     ngx_table_elt_t  *ho;

  4466.     ho = ngx_list_push(&r->headers_out.headers);
  4467.     if (ho == NULL) {
  4468.         return NGX_ERROR;
  4469.     }

  4471.     *ho = *h;

  4473.     if (r->upstream->rewrite_redirect) {
  4474.         rc = r->upstream->rewrite_redirect(r, ho, 0);

  4476.         if (rc == NGX_DECLINED) {
  4477.             return NGX_OK;
  4478.         }

  4480.         if (rc == NGX_OK) {
  4481.             r->headers_out.location = ho;

  4483.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4484.                            "rewritten location: \"%V\"", &ho->value);
  4485.         }

  4487.         return rc;
  4488.     }

  4490.     if (ho->value.data[0] != '/') {
  4491.         r->headers_out.location = ho;
  4492.     }

  4494.     /*
  4495.      * we do not set r->headers_out.location here to avoid the handling
  4496.      * the local redirects without a host name by ngx_http_header_filter()
  4497.      */

  4499.     return NGX_OK;
  4500. }


  4503. static ngx_int_t
  4504. ‌ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r, ngx_table_elt_t *h,
  4505.     ngx_uint_t offset)
  4506. {
  4507.     u_char           *p;
  4508.     ngx_int_t         rc;
  4509.     ngx_table_elt_t  *ho;

  4511.     ho = ngx_list_push(&r->headers_out.headers);
  4512.     if (ho == NULL) {
  4513.         return NGX_ERROR;
  4514.     }

  4516.     *ho = *h;

  4518.     if (r->upstream->rewrite_redirect) {

  4520.         p = ngx_strcasestrn(ho->value.data, "url=", 4 - 1);

  4522.         if (p) {
  4523.             rc = r->upstream->rewrite_redirect(r, ho, p + 4 - ho->value.data);

  4525.         } else {
  4526.             return NGX_OK;
  4527.         }

  4529.         if (rc == NGX_DECLINED) {
  4530.             return NGX_OK;
  4531.         }

  4533.         if (rc == NGX_OK) {
  4534.             r->headers_out.refresh = ho;

  4536.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4537.                            "rewritten refresh: \"%V\"", &ho->value);
  4538.         }

  4540.         return rc;
  4541.     }

  4543.     r->headers_out.refresh = ho;

  4545.     return NGX_OK;
  4546. }


  4549. static ngx_int_t
  4550. ‌ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  4551.     ngx_uint_t offset)
  4552. {
  4553.     ngx_int_t         rc;
  4554.     ngx_table_elt_t  *ho;

  4556.     ho = ngx_list_push(&r->headers_out.headers);
  4557.     if (ho == NULL) {
  4558.         return NGX_ERROR;
  4559.     }

  4561.     *ho = *h;

  4563.     if (r->upstream->rewrite_cookie) {
  4564.         rc = r->upstream->rewrite_cookie(r, ho);

  4566.         if (rc == NGX_DECLINED) {
  4567.             return NGX_OK;
  4568.         }

  4570. #if (NGX_DEBUG)
  4571.         if (rc == NGX_OK) {
  4572.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4573.                            "rewritten cookie: \"%V\"", &ho->value);
  4574.         }
  4575. #endif

  4577.         return rc;
  4578.     }

  4580.     return NGX_OK;
  4581. }


  4584. static ngx_int_t
  4585. ‌ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  4586.     ngx_table_elt_t *h, ngx_uint_t offset)
  4587. {
  4588.     ngx_table_elt_t  *ho;

  4590.     if (r->upstream->conf->force_ranges) {
  4591.         return NGX_OK;
  4592.     }

  4594. #if (NGX_HTTP_CACHE)

  4596.     if (r->cached) {
  4597.         r->allow_ranges = 1;
  4598.         return NGX_OK;
  4599.     }

  4601.     if (r->upstream->cacheable) {
  4602.         r->allow_ranges = 1;
  4603.         r->single_range = 1;
  4604.         return NGX_OK;
  4605.     }

  4607. #endif

  4609.     ho = ngx_list_push(&r->headers_out.headers);
  4610.     if (ho == NULL) {
  4611.         return NGX_ERROR;
  4612.     }

  4614.     *ho = *h;

  4616.     r->headers_out.accept_ranges = ho;

  4618.     return NGX_OK;
  4619. }


  4622. #if (NGX_HTTP_GZIP)

  4624. static ngx_int_t
  4625. ‌ngx_http_upstream_copy_content_encoding(ngx_http_request_t *r,
  4626.     ngx_table_elt_t *h, ngx_uint_t offset)
  4627. {
  4628.     ngx_table_elt_t  *ho;

  4630.     ho = ngx_list_push(&r->headers_out.headers);
  4631.     if (ho == NULL) {
  4632.         return NGX_ERROR;
  4633.     }

  4635.     *ho = *h;

  4637.     r->headers_out.content_encoding = ho;

  4639.     return NGX_OK;
  4640. }

  4642. #endif


  4645. static ngx_int_t
  4646. ‌ngx_http_upstream_add_variables(ngx_conf_t *cf)
  4647. {
  4648.     ngx_http_variable_t  *var, *v;

  4650.     for (v = ngx_http_upstream_vars; v->name.len; v++) {
  4651.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  4652.         if (var == NULL) {
  4653.             return NGX_ERROR;
  4654.         }

  4656.         var->get_handler = v->get_handler;
  4657.         var->data = v->data;
  4658.     }

  4660.     return NGX_OK;
  4661. }


  4664. static ngx_int_t
  4665. ‌ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  4666.     ngx_http_variable_value_t *v, uintptr_t data)
  4667. {
  4668.     u_char                     *p;
  4669.     size_t                      len;
  4670.     ngx_uint_t                  i;
  4671.     ngx_http_upstream_state_t  *state;

  4673.     v->valid = 1;
  4674.     v->no_cacheable = 0;
  4675.     v->not_found = 0;

  4677.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  4678.         v->not_found = 1;
  4679.         return NGX_OK;
  4680.     }

  4682.     len = 0;
  4683.     state = r->upstream_states->elts;

  4685.     for (i = 0; i < r->upstream_states->nelts; i++) {
  4686.         if (state[i].peer) {
  4687.             len += state[i].peer->len + 2;

  4689.         } else {
  4690.             len += 3;
  4691.         }
  4692.     }

  4694.     p = ngx_pnalloc(r->pool, len);
  4695.     if (p == NULL) {
  4696.         return NGX_ERROR;
  4697.     }

  4699.     v->data = p;

  4701.     i = 0;

  4703.     for ( ;; ) {
  4704.         if (state[i].peer) {
  4705.             p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
  4706.         }

  4708.         if (++i == r->upstream_states->nelts) {
  4709.             break;
  4710.         }

  4712.         if (state[i].peer) {
  4713.             *p++ = ',';
  4714.             *p++ = ' ';

  4716.         } else {
  4717.             *p++ = ' ';
  4718.             *p++ = ':';
  4719.             *p++ = ' ';

  4721.             if (++i == r->upstream_states->nelts) {
  4722.                 break;
  4723.             }

  4725.             continue;
  4726.         }
  4727.     }

  4729.     v->len = p - v->data;

  4731.     return NGX_OK;
  4732. }


  4735. static ngx_int_t
  4736. ‌ngx_http_upstream_status_variable(ngx_http_request_t *r,
  4737.     ngx_http_variable_value_t *v, uintptr_t data)
  4738. {
  4739.     u_char                     *p;
  4740.     size_t                      len;
  4741.     ngx_uint_t                  i;
  4742.     ngx_http_upstream_state_t  *state;

  4744.     v->valid = 1;
  4745.     v->no_cacheable = 0;
  4746.     v->not_found = 0;

  4748.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  4749.         v->not_found = 1;
  4750.         return NGX_OK;
  4751.     }

  4753.     len = r->upstream_states->nelts * (3 + 2);

  4755.     p = ngx_pnalloc(r->pool, len);
  4756.     if (p == NULL) {
  4757.         return NGX_ERROR;
  4758.     }

  4760.     v->data = p;

  4762.     i = 0;
  4763.     state = r->upstream_states->elts;

  4765.     for ( ;; ) {
  4766.         if (state[i].status) {
  4767.             p = ngx_sprintf(p, "%ui", state[i].status);

  4769.         } else {
  4770.             *p++ = '-';
  4771.         }

  4773.         if (++i == r->upstream_states->nelts) {
  4774.             break;
  4775.         }

  4777.         if (state[i].peer) {
  4778.             *p++ = ',';
  4779.             *p++ = ' ';

  4781.         } else {
  4782.             *p++ = ' ';
  4783.             *p++ = ':';
  4784.             *p++ = ' ';

  4786.             if (++i == r->upstream_states->nelts) {
  4787.                 break;
  4788.             }

  4790.             continue;
  4791.         }
  4792.     }

  4794.     v->len = p - v->data;

  4796.     return NGX_OK;
  4797. }


  4800. static ngx_int_t
  4801. ‌ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  4802.     ngx_http_variable_value_t *v, uintptr_t data)
  4803. {
  4804.     u_char                     *p;
  4805.     size_t                      len;
  4806.     ngx_uint_t                  i;
  4807.     ngx_msec_int_t              ms;
  4808.     ngx_http_upstream_state_t  *state;

  4810.     v->valid = 1;
  4811.     v->no_cacheable = 0;
  4812.     v->not_found = 0;

  4814.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  4815.         v->not_found = 1;
  4816.         return NGX_OK;
  4817.     }

  4819.     len = r->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);

  4821.     p = ngx_pnalloc(r->pool, len);
  4822.     if (p == NULL) {
  4823.         return NGX_ERROR;
  4824.     }

  4826.     v->data = p;

  4828.     i = 0;
  4829.     state = r->upstream_states->elts;

  4831.     for ( ;; ) {
  4832.         if (state[i].status) {

  4834.             if (data
  4835.                 && state[i].header_sec != (time_t) NGX_ERROR)
  4836.             {
  4837.                 ms = (ngx_msec_int_t)
  4838.                       (state[i].header_sec * 1000 + state[i].header_msec);

  4840.             } else {
  4841.                 ms = (ngx_msec_int_t)
  4842.                       (state[i].response_sec * 1000 + state[i].response_msec);
  4843.             }

  4845.             ms = ngx_max(ms, 0);
  4846.             p = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000);

  4848.         } else {
  4849.             *p++ = '-';
  4850.         }

  4852.         if (++i == r->upstream_states->nelts) {
  4853.             break;
  4854.         }

  4856.         if (state[i].peer) {
  4857.             *p++ = ',';
  4858.             *p++ = ' ';

  4860.         } else {
  4861.             *p++ = ' ';
  4862.             *p++ = ':';
  4863.             *p++ = ' ';

  4865.             if (++i == r->upstream_states->nelts) {
  4866.                 break;
  4867.             }

  4869.             continue;
  4870.         }
  4871.     }

  4873.     v->len = p - v->data;

  4875.     return NGX_OK;
  4876. }


  4879. static ngx_int_t
  4880. ‌ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
  4881.     ngx_http_variable_value_t *v, uintptr_t data)
  4882. {
  4883.     u_char                     *p;
  4884.     size_t                      len;
  4885.     ngx_uint_t                  i;
  4886.     ngx_http_upstream_state_t  *state;

  4888.     v->valid = 1;
  4889.     v->no_cacheable = 0;
  4890.     v->not_found = 0;

  4892.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  4893.         v->not_found = 1;
  4894.         return NGX_OK;
  4895.     }

  4897.     len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);

  4899.     p = ngx_pnalloc(r->pool, len);
  4900.     if (p == NULL) {
  4901.         return NGX_ERROR;
  4902.     }

  4904.     v->data = p;

  4906.     i = 0;
  4907.     state = r->upstream_states->elts;

  4909.     for ( ;; ) {
  4910.         p = ngx_sprintf(p, "%O", state[i].response_length);

  4912.         if (++i == r->upstream_states->nelts) {
  4913.             break;
  4914.         }

  4916.         if (state[i].peer) {
  4917.             *p++ = ',';
  4918.             *p++ = ' ';

  4920.         } else {
  4921.             *p++ = ' ';
  4922.             *p++ = ':';
  4923.             *p++ = ' ';

  4925.             if (++i == r->upstream_states->nelts) {
  4926.                 break;
  4927.             }

  4929.             continue;
  4930.         }
  4931.     }

  4933.     v->len = p - v->data;

  4935.     return NGX_OK;
  4936. }


  4939. ngx_int_t
  4940. ‌ngx_http_upstream_header_variable(ngx_http_request_t *r,
  4941.     ngx_http_variable_value_t *v, uintptr_t data)
  4942. {
  4943.     if (r->upstream == NULL) {
  4944.         v->not_found = 1;
  4945.         return NGX_OK;
  4946.     }

  4948.     return ngx_http_variable_unknown_header(v, (ngx_str_t *) data,
  4949.                                          &r->upstream->headers_in.headers.part,
  4950.                                          sizeof("upstream_http_") - 1);
  4951. }


  4954. ngx_int_t
  4955. ‌ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  4956.     ngx_http_variable_value_t *v, uintptr_t data)
  4957. {
  4958.     ngx_str_t  *name = (ngx_str_t *) data;

  4960.     ngx_str_t   cookie, s;

  4962.     if (r->upstream == NULL) {
  4963.         v->not_found = 1;
  4964.         return NGX_OK;
  4965.     }

  4967.     s.len = name->len - (sizeof("upstream_cookie_") - 1);
  4968.     s.data = name->data + sizeof("upstream_cookie_") - 1;

  4970.     if (ngx_http_parse_set_cookie_lines(&r->upstream->headers_in.cookies,
  4971.                                         &s, &cookie)
  4972.         == NGX_DECLINED)
  4973.     {
  4974.         v->not_found = 1;
  4975.         return NGX_OK;
  4976.     }

  4978.     v->len = cookie.len;
  4979.     v->valid = 1;
  4980.     v->no_cacheable = 0;
  4981.     v->not_found = 0;
  4982.     v->data = cookie.data;

  4984.     return NGX_OK;
  4985. }


  4988. #if (NGX_HTTP_CACHE)

  4990. ngx_int_t
  4991. ‌ngx_http_upstream_cache_status(ngx_http_request_t *r,
  4992.     ngx_http_variable_value_t *v, uintptr_t data)
  4993. {
  4994.     ngx_uint_t  n;

  4996.     if (r->upstream == NULL || r->upstream->cache_status == 0) {
  4997.         v->not_found = 1;
  4998.         return NGX_OK;
  4999.     }

  5001.     n = r->upstream->cache_status - 1;

  5003.     v->valid = 1;
  5004.     v->no_cacheable = 0;
  5005.     v->not_found = 0;
  5006.     v->len = ngx_http_cache_status[n].len;
  5007.     v->data = ngx_http_cache_status[n].data;

  5009.     return NGX_OK;
  5010. }


  5013. static ngx_int_t
  5014. ‌ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  5015.     ngx_http_variable_value_t *v, uintptr_t data)
  5016. {
  5017.     u_char  *p;

  5019.     if (r->upstream == NULL
  5020.         || !r->upstream->conf->cache_revalidate
  5021.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  5022.         || r->cache->last_modified == -1)
  5023.     {
  5024.         v->not_found = 1;
  5025.         return NGX_OK;
  5026.     }

  5028.     p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  5029.     if (p == NULL) {
  5030.         return NGX_ERROR;
  5031.     }

  5033.     v->len = ngx_http_time(p, r->cache->last_modified) - p;
  5034.     v->valid = 1;
  5035.     v->no_cacheable = 0;
  5036.     v->not_found = 0;
  5037.     v->data = p;

  5039.     return NGX_OK;
  5040. }


  5043. static ngx_int_t
  5044. ‌ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  5045.     ngx_http_variable_value_t *v, uintptr_t data)
  5046. {
  5047.     if (r->upstream == NULL
  5048.         || !r->upstream->conf->cache_revalidate
  5049.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  5050.         || r->cache->etag.len == 0)
  5051.     {
  5052.         v->not_found = 1;
  5053.         return NGX_OK;
  5054.     }

  5056.     v->valid = 1;
  5057.     v->no_cacheable = 0;
  5058.     v->not_found = 0;
  5059.     v->len = r->cache->etag.len;
  5060.     v->data = r->cache->etag.data;

  5062.     return NGX_OK;
  5063. }

  5065. #endif


  5068. static char *
  5069. ‌ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  5070. {
  5071.     char                          *rv;
  5072.     void                          *mconf;
  5073.     ngx_str_t                     *value;
  5074.     ngx_url_t                      u;
  5075.     ngx_uint_t                     m;
  5076.     ngx_conf_t                     pcf;
  5077.     ngx_http_module_t             *module;
  5078.     ngx_http_conf_ctx_t           *ctx, *http_ctx;
  5079.     ngx_http_upstream_srv_conf_t  *uscf;

  5081.     ngx_memzero(&u, sizeof(ngx_url_t));

  5083.     value = cf->args->elts;
  5084.     u.host = value[1];
  5085.     u.no_resolve = 1;
  5086.     u.no_port = 1;

  5088.     uscf = ngx_http_upstream_add(cf, &u, NGX_HTTP_UPSTREAM_CREATE
  5089.                                          |NGX_HTTP_UPSTREAM_WEIGHT
  5090.                                          |NGX_HTTP_UPSTREAM_MAX_FAILS
  5091.                                          |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  5092.                                          |NGX_HTTP_UPSTREAM_DOWN
  5093.                                          |NGX_HTTP_UPSTREAM_BACKUP);
  5094.     if (uscf == NULL) {
  5095.         return NGX_CONF_ERROR;
  5096.     }


  5099.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  5100.     if (ctx == NULL) {
  5101.         return NGX_CONF_ERROR;
  5102.     }

  5104.     http_ctx = cf->ctx;
  5105.     ctx->main_conf = http_ctx->main_conf;

  5107.     /* the upstream{}'s srv_conf */

  5109.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  5110.     if (ctx->srv_conf == NULL) {
  5111.         return NGX_CONF_ERROR;
  5112.     }

  5114.     ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;

  5116.     uscf->srv_conf = ctx->srv_conf;


  5119.     /* the upstream{}'s loc_conf */

  5121.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  5122.     if (ctx->loc_conf == NULL) {
  5123.         return NGX_CONF_ERROR;
  5124.     }

  5126.     for (m = 0; ngx_modules[m]; m++) {
  5127.         if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
  5128.             continue;
  5129.         }

  5131.         module = ngx_modules[m]->ctx;

  5133.         if (module->create_srv_conf) {
  5134.             mconf = module->create_srv_conf(cf);
  5135.             if (mconf == NULL) {
  5136.                 return NGX_CONF_ERROR;
  5137.             }

  5139.             ctx->srv_conf[ngx_modules[m]->ctx_index] = mconf;
  5140.         }

  5142.         if (module->create_loc_conf) {
  5143.             mconf = module->create_loc_conf(cf);
  5144.             if (mconf == NULL) {
  5145.                 return NGX_CONF_ERROR;
  5146.             }

  5148.             ctx->loc_conf[ngx_modules[m]->ctx_index] = mconf;
  5149.         }
  5150.     }

  5152.     uscf->servers = ngx_array_create(cf->pool, 4,
  5153.                                      sizeof(ngx_http_upstream_server_t));
  5154.     if (uscf->servers == NULL) {
  5155.         return NGX_CONF_ERROR;
  5156.     }


  5159.     /* parse inside upstream{} */

  5161.     pcf = *cf;
  5162.     cf->ctx = ctx;
  5163.     cf->cmd_type = NGX_HTTP_UPS_CONF;

  5165.     rv = ngx_conf_parse(cf, NULL);

  5167.     *cf = pcf;

  5169.     if (rv != NGX_CONF_OK) {
  5170.         return rv;
  5171.     }

  5173.     if (uscf->servers->nelts == 0) {
  5174.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5175.                            "no servers are inside upstream");
  5176.         return NGX_CONF_ERROR;
  5177.     }

  5179.     return rv;
  5180. }


  5183. static char *
  5184. ‌ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  5185. {
  5186.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  5188.     time_t                       fail_timeout;
  5189.     ngx_str_t                   *value, s;
  5190.     ngx_url_t                    u;
  5191.     ngx_int_t                    weight, max_fails;
  5192.     ngx_uint_t                   i;
  5193.     ngx_http_upstream_server_t  *us;

  5195.     us = ngx_array_push(uscf->servers);
  5196.     if (us == NULL) {
  5197.         return NGX_CONF_ERROR;
  5198.     }

  5200.     ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  5202.     value = cf->args->elts;

  5204.     weight = 1;
  5205.     max_fails = 1;
  5206.     fail_timeout = 10;

  5208.     for (i = 2; i < cf->args->nelts; i++) {

  5210.         if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {

  5212.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_WEIGHT)) {
  5213.                 goto not_supported;
  5214.             }

  5216.             weight = ngx_atoi(&value[i].data[7], value[i].len - 7);

  5218.             if (weight == NGX_ERROR || weight == 0) {
  5219.                 goto invalid;
  5220.             }

  5222.             continue;
  5223.         }

  5225.         if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {

  5227.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_FAILS)) {
  5228.                 goto not_supported;
  5229.             }

  5231.             max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);

  5233.             if (max_fails == NGX_ERROR) {
  5234.                 goto invalid;
  5235.             }

  5237.             continue;
  5238.         }

  5240.         if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {

  5242.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_FAIL_TIMEOUT)) {
  5243.                 goto not_supported;
  5244.             }

  5246.             s.len = value[i].len - 13;
  5247.             s.data = &value[i].data[13];

  5249.             fail_timeout = ngx_parse_time(&s, 1);

  5251.             if (fail_timeout == (time_t) NGX_ERROR) {
  5252.                 goto invalid;
  5253.             }

  5255.             continue;
  5256.         }

  5258.         if (ngx_strcmp(value[i].data, "backup") == 0) {

  5260.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  5261.                 goto not_supported;
  5262.             }

  5264.             us->backup = 1;

  5266.             continue;
  5267.         }

  5269.         if (ngx_strcmp(value[i].data, "down") == 0) {

  5271.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  5272.                 goto not_supported;
  5273.             }

  5275.             us->down = 1;

  5277.             continue;
  5278.         }

  5280.         goto invalid;
  5281.     }

  5283.     ngx_memzero(&u, sizeof(ngx_url_t));

  5285.     u.url = value[1];
  5286.     u.default_port = 80;

  5288.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  5289.         if (u.err) {
  5290.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5291.                                "%s in upstream \"%V\"", u.err, &u.url);
  5292.         }

  5294.         return NGX_CONF_ERROR;
  5295.     }

  5297.     us->name = u.url;
  5298.     us->addrs = u.addrs;
  5299.     us->naddrs = u.naddrs;
  5300.     us->weight = weight;
  5301.     us->max_fails = max_fails;
  5302.     us->fail_timeout = fail_timeout;

  5304.     return NGX_CONF_OK;

  5306. invalid:

  5308.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5309.                        "invalid parameter \"%V\"", &value[i]);

  5311.     return NGX_CONF_ERROR;

  5313. not_supported:

  5315.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5316.                        "balancing method does not support parameter \"%V\"",
  5317.                        &value[i]);

  5319.     return NGX_CONF_ERROR;
  5320. }


  5323. ngx_http_upstream_srv_conf_t *
  5324. ‌ngx_http_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
  5325. {
  5326.     ngx_uint_t                      i;
  5327.     ngx_http_upstream_server_t     *us;
  5328.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  5329.     ngx_http_upstream_main_conf_t  *umcf;

  5331.     if (!(flags & NGX_HTTP_UPSTREAM_CREATE)) {

  5333.         if (ngx_parse_url(cf->pool, u) != NGX_OK) {
  5334.             if (u->err) {
  5335.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5336.                                    "%s in upstream \"%V\"", u->err, &u->url);
  5337.             }

  5339.             return NULL;
  5340.         }
  5341.     }

  5343.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

  5345.     uscfp = umcf->upstreams.elts;

  5347.     for (i = 0; i < umcf->upstreams.nelts; i++) {

  5349.         if (uscfp[i]->host.len != u->host.len
  5350.             || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
  5351.                != 0)
  5352.         {
  5353.             continue;
  5354.         }

  5356.         if ((flags & NGX_HTTP_UPSTREAM_CREATE)
  5357.              && (uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE))
  5358.         {
  5359.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5360.                                "duplicate upstream \"%V\"", &u->host);
  5361.             return NULL;
  5362.         }

  5364.         if ((uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE) && !u->no_port) {
  5365.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  5366.                                "upstream \"%V\" may not have port %d",
  5367.                                &u->host, u->port);
  5368.             return NULL;
  5369.         }

  5371.         if ((flags & NGX_HTTP_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
  5372.             ngx_log_error(NGX_LOG_WARN, cf->log, 0,
  5373.                           "upstream \"%V\" may not have port %d in %s:%ui",
  5374.                           &u->host, uscfp[i]->port,
  5375.                           uscfp[i]->file_name, uscfp[i]->line);
  5376.             return NULL;
  5377.         }

  5379.         if (uscfp[i]->port && u->port
  5380.             && uscfp[i]->port != u->port)
  5381.         {
  5382.             continue;
  5383.         }

  5385.         if (uscfp[i]->default_port && u->default_port
  5386.             && uscfp[i]->default_port != u->default_port)
  5387.         {
  5388.             continue;
  5389.         }

  5391.         if (flags & NGX_HTTP_UPSTREAM_CREATE) {
  5392.             uscfp[i]->flags = flags;
  5393.         }

  5395.         return uscfp[i];
  5396.     }

  5398.     uscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
  5399.     if (uscf == NULL) {
  5400.         return NULL;
  5401.     }

  5403.     uscf->flags = flags;
  5404.     uscf->host = u->host;
  5405.     uscf->file_name = cf->conf_file->file.name.data;
  5406.     uscf->line = cf->conf_file->line;
  5407.     uscf->port = u->port;
  5408.     uscf->default_port = u->default_port;
  5409.     uscf->no_port = u->no_port;

  5411.     if (u->naddrs == 1) {
  5412.         uscf->servers = ngx_array_create(cf->pool, 1,
  5413.                                          sizeof(ngx_http_upstream_server_t));
  5414.         if (uscf->servers == NULL) {
  5415.             return NULL;
  5416.         }

  5418.         us = ngx_array_push(uscf->servers);
  5419.         if (us == NULL) {
  5420.             return NULL;
  5421.         }

  5423.         ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  5425.         us->addrs = u->addrs;
  5426.         us->naddrs = 1;
  5427.     }

  5429.     uscfp = ngx_array_push(&umcf->upstreams);
  5430.     if (uscfp == NULL) {
  5431.         return NULL;
  5432.     }

  5434.     *uscfp = uscf;

  5436.     return uscf;
  5437. }


  5440. char *
  5441. ‌ngx_http_upstream_bind_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  5442.     void *conf)
  5443. {
  5444.     char  *p = conf;

  5446.     ngx_int_t                           rc;
  5447.     ngx_str_t                          *value;
  5448.     ngx_http_complex_value_t            cv;
  5449.     ngx_http_upstream_local_t         **plocal, *local;
  5450.     ngx_http_compile_complex_value_t    ccv;

  5452.     plocal = (ngx_http_upstream_local_t **) (p + cmd->offset);

  5454.     if (*plocal != NGX_CONF_UNSET_PTR) {
  5455.         return "is duplicate";
  5456.     }

  5458.     value = cf->args->elts;

  5460.     if (ngx_strcmp(value[1].data, "off") == 0) {
  5461.         *plocal = NULL;
  5462.         return NGX_CONF_OK;
  5463.     }

  5465.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  5467.     ccv.cf = cf;
  5468.     ccv.value = &value[1];
  5469.     ccv.complex_value = &cv;

  5471.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  5472.         return NGX_CONF_ERROR;
  5473.     }

  5475.     local = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_local_t));
  5476.     if (local == NULL) {
  5477.         return NGX_CONF_ERROR;
  5478.     }

  5480.     *plocal = local;

  5482.     if (cv.lengths) {
  5483.         local->value = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  5484.         if (local->value == NULL) {
  5485.             return NGX_CONF_ERROR;
  5486.         }

  5488.         *local->value = cv;

  5490.         return NGX_CONF_OK;
  5491.     }

  5493.     local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  5494.     if (local->addr == NULL) {
  5495.         return NGX_CONF_ERROR;
  5496.     }

  5498.     rc = ngx_parse_addr(cf->pool, local->addr, value[1].data, value[1].len);

  5500.     switch (rc) {
  5501.     case NGX_OK:
  5502.         local->addr->name = value[1];
  5503.         return NGX_CONF_OK;

  5505.     case NGX_DECLINED:
  5506.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5507.                            "invalid address \"%V\"", &value[1]);
  5508.         /* fall through */

  5510.     default:
  5511.         return NGX_CONF_ERROR;
  5512.     }
  5513. }


  5516. static ngx_addr_t *
  5517. ‌ngx_http_upstream_get_local(ngx_http_request_t *r,
  5518.     ngx_http_upstream_local_t *local)
  5519. {
  5520.     ngx_int_t    rc;
  5521.     ngx_str_t    val;
  5522.     ngx_addr_t  *addr;

  5524.     if (local == NULL) {
  5525.         return NULL;
  5526.     }

  5528.     if (local->value == NULL) {
  5529.         return local->addr;
  5530.     }

  5532.     if (ngx_http_complex_value(r, local->value, &val) != NGX_OK) {
  5533.         return NULL;
  5534.     }

  5536.     if (val.len == 0) {
  5537.         return NULL;
  5538.     }

  5540.     addr = ngx_palloc(r->pool, sizeof(ngx_addr_t));
  5541.     if (addr == NULL) {
  5542.         return NULL;
  5543.     }

  5545.     rc = ngx_parse_addr(r->pool, addr, val.data, val.len);

  5547.     switch (rc) {
  5548.     case NGX_OK:
  5549.         addr->name = val;
  5550.         return addr;

  5552.     case NGX_DECLINED:
  5553.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5554.                       "invalid local address \"%V\"", &val);
  5555.         /* fall through */

  5557.     default:
  5558.         return NULL;
  5559.     }
  5560. }


  5563. char *
  5564. ‌ngx_http_upstream_param_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  5565.     void *conf)
  5566. {
  5567.     char  *p = conf;

  5569.     ngx_str_t                   *value;
  5570.     ngx_array_t                **a;
  5571.     ngx_http_upstream_param_t   *param;

  5573.     a = (ngx_array_t **) (p + cmd->offset);

  5575.     if (*a == NULL) {
  5576.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_param_t));
  5577.         if (*a == NULL) {
  5578.             return NGX_CONF_ERROR;
  5579.         }
  5580.     }

  5582.     param = ngx_array_push(*a);
  5583.     if (param == NULL) {
  5584.         return NGX_CONF_ERROR;
  5585.     }

  5587.     value = cf->args->elts;

  5589.     param->key = value[1];
  5590.     param->value = value[2];
  5591.     param->skip_empty = 0;

  5593.     if (cf->args->nelts == 4) {
  5594.         if (ngx_strcmp(value[3].data, "if_not_empty") != 0) {
  5595.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  5596.                                "invalid parameter \"%V\"", &value[3]);
  5597.             return NGX_CONF_ERROR;
  5598.         }

  5600.         param->skip_empty = 1;
  5601.     }

  5603.     return NGX_CONF_OK;
  5604. }


  5607. ngx_int_t
  5608. ‌ngx_http_upstream_hide_headers_hash(ngx_conf_t *cf,
  5609.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev,
  5610.     ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
  5611. {
  5612.     ngx_str_t       *h;
  5613.     ngx_uint_t       i, j;
  5614.     ngx_array_t      hide_headers;
  5615.     ngx_hash_key_t  *hk;

  5617.     if (conf->hide_headers == NGX_CONF_UNSET_PTR
  5618.         && conf->pass_headers == NGX_CONF_UNSET_PTR)
  5619.     {
  5620.         conf->hide_headers = prev->hide_headers;
  5621.         conf->pass_headers = prev->pass_headers;

  5623.         conf->hide_headers_hash = prev->hide_headers_hash;

  5625.         if (conf->hide_headers_hash.buckets
  5626. #if (NGX_HTTP_CACHE)
  5627.             && ((conf->cache == 0) == (prev->cache == 0))
  5628. #endif
  5629.            )
  5630.         {
  5631.             return NGX_OK;
  5632.         }

  5634.     } else {
  5635.         if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
  5636.             conf->hide_headers = prev->hide_headers;
  5637.         }

  5639.         if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
  5640.             conf->pass_headers = prev->pass_headers;
  5641.         }
  5642.     }

  5644.     if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  5645.         != NGX_OK)
  5646.     {
  5647.         return NGX_ERROR;
  5648.     }

  5650.     for (h = default_hide_headers; h->len; h++) {
  5651.         hk = ngx_array_push(&hide_headers);
  5652.         if (hk == NULL) {
  5653.             return NGX_ERROR;
  5654.         }

  5656.         hk->key = *h;
  5657.         hk->key_hash = ngx_hash_key_lc(h->data, h->len);
  5658.         hk->value = (void *) 1;
  5659.     }

  5661.     if (conf->hide_headers != NGX_CONF_UNSET_PTR) {

  5663.         h = conf->hide_headers->elts;

  5665.         for (i = 0; i < conf->hide_headers->nelts; i++) {

  5667.             hk = hide_headers.elts;

  5669.             for (j = 0; j < hide_headers.nelts; j++) {
  5670.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  5671.                     goto exist;
  5672.                 }
  5673.             }

  5675.             hk = ngx_array_push(&hide_headers);
  5676.             if (hk == NULL) {
  5677.                 return NGX_ERROR;
  5678.             }

  5680.             hk->key = h[i];
  5681.             hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
  5682.             hk->value = (void *) 1;

  5684.         exist:

  5686.             continue;
  5687.         }
  5688.     }

  5690.     if (conf->pass_headers != NGX_CONF_UNSET_PTR) {

  5692.         h = conf->pass_headers->elts;
  5693.         hk = hide_headers.elts;

  5695.         for (i = 0; i < conf->pass_headers->nelts; i++) {
  5696.             for (j = 0; j < hide_headers.nelts; j++) {

  5698.                 if (hk[j].key.data == NULL) {
  5699.                     continue;
  5700.                 }

  5702.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  5703.                     hk[j].key.data = NULL;
  5704.                     break;
  5705.                 }
  5706.             }
  5707.         }
  5708.     }

  5710.     hash->hash = &conf->hide_headers_hash;
  5711.     hash->key = ngx_hash_key_lc;
  5712.     hash->pool = cf->pool;
  5713.     hash->temp_pool = NULL;

  5715.     return ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts);
  5716. }


  5719. static void *
  5720. ‌ngx_http_upstream_create_main_conf(ngx_conf_t *cf)
  5721. {
  5722.     ngx_http_upstream_main_conf_t  *umcf;

  5724.     umcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_main_conf_t));
  5725.     if (umcf == NULL) {
  5726.         return NULL;
  5727.     }

  5729.     if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
  5730.                        sizeof(ngx_http_upstream_srv_conf_t *))
  5731.         != NGX_OK)
  5732.     {
  5733.         return NULL;
  5734.     }

  5736.     return umcf;
  5737. }


  5740. static char *
  5741. ‌ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
  5742. {
  5743.     ngx_http_upstream_main_conf_t  *umcf = conf;

  5745.     ngx_uint_t                      i;
  5746.     ngx_array_t                     headers_in;
  5747.     ngx_hash_key_t                 *hk;
  5748.     ngx_hash_init_t                 hash;
  5749.     ngx_http_upstream_init_pt       init;
  5750.     ngx_http_upstream_header_t     *header;
  5751.     ngx_http_upstream_srv_conf_t  **uscfp;

  5753.     uscfp = umcf->upstreams.elts;

  5755.     for (i = 0; i < umcf->upstreams.nelts; i++) {

  5757.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:
  5758.                                             ngx_http_upstream_init_round_robin;

  5760.         if (init(cf, uscfp[i]) != NGX_OK) {
  5761.             return NGX_CONF_ERROR;
  5762.         }
  5763.     }


  5766.     /* upstream_headers_in_hash */

  5768.     if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
  5769.         != NGX_OK)
  5770.     {
  5771.         return NGX_CONF_ERROR;
  5772.     }

  5774.     for (header = ngx_http_upstream_headers_in; header->name.len; header++) {
  5775.         hk = ngx_array_push(&headers_in);
  5776.         if (hk == NULL) {
  5777.             return NGX_CONF_ERROR;
  5778.         }

  5780.         hk->key = header->name;
  5781.         hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
  5782.         hk->value = header;
  5783.     }

  5785.     hash.hash = &umcf->headers_in_hash;
  5786.     hash.key = ngx_hash_key_lc;
  5787.     hash.max_size = 512;
  5788.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  5789.     hash.name = "upstream_headers_in_hash";
  5790.     hash.pool = cf->pool;
  5791.     hash.temp_pool = NULL;

  5793.     if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
  5794.         return NGX_CONF_ERROR;
  5795.     }

  5797.     return NGX_CONF_OK;
  5798. }

One Level Up Top Level