One Level Up Top Level

src/http/ngx_http_upstream.c - nginx source code

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_background_update(
  21.     ngx_http_request_t *r, ngx_http_upstream_t *u);
  22. static ngx_int_t ngx_http_upstream_cache_check_range(ngx_http_request_t *r,
  23.     ngx_http_upstream_t *u);
  24. static ngx_int_t ngx_http_upstream_cache_status(ngx_http_request_t *r,
  25.     ngx_http_variable_value_t *v, uintptr_t data);
  26. static ngx_int_t ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  27.     ngx_http_variable_value_t *v, uintptr_t data);
  28. static ngx_int_t ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  29.     ngx_http_variable_value_t *v, uintptr_t data);
  30. #endif

  32. static void ngx_http_upstream_init_request(ngx_http_request_t *r);
  33. static void ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx);
  34. static void ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r);
  35. static void ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r);
  36. static void ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  37.     ngx_event_t *ev);
  38. static void ngx_http_upstream_connect(ngx_http_request_t *r,
  39.     ngx_http_upstream_t *u);
  40. static ngx_int_t ngx_http_upstream_reinit(ngx_http_request_t *r,
  41.     ngx_http_upstream_t *u);
  42. static void ngx_http_upstream_send_request(ngx_http_request_t *r,
  43.     ngx_http_upstream_t *u, ngx_uint_t do_write);
  44. static ngx_int_t ngx_http_upstream_send_request_body(ngx_http_request_t *r,
  45.     ngx_http_upstream_t *u, ngx_uint_t do_write);
  46. static void ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  47.     ngx_http_upstream_t *u);
  48. static void ngx_http_upstream_read_request_handler(ngx_http_request_t *r);
  49. static void ngx_http_upstream_process_header(ngx_http_request_t *r,
  50.     ngx_http_upstream_t *u);
  51. static ngx_int_t ngx_http_upstream_test_next(ngx_http_request_t *r,
  52.     ngx_http_upstream_t *u);
  53. static ngx_int_t ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  54.     ngx_http_upstream_t *u);
  55. static ngx_int_t ngx_http_upstream_test_connect(ngx_connection_t *c);
  56. static ngx_int_t ngx_http_upstream_process_headers(ngx_http_request_t *r,
  57.     ngx_http_upstream_t *u);
  58. static ngx_int_t ngx_http_upstream_process_trailers(ngx_http_request_t *r,
  59.     ngx_http_upstream_t *u);
  60. static void ngx_http_upstream_send_response(ngx_http_request_t *r,
  61.     ngx_http_upstream_t *u);
  62. static void ngx_http_upstream_upgrade(ngx_http_request_t *r,
  63.     ngx_http_upstream_t *u);
  64. static void ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r);
  65. static void ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r);
  66. static void ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  67.     ngx_http_upstream_t *u);
  68. static void ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  69.     ngx_http_upstream_t *u);
  70. static void ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  71.     ngx_uint_t from_upstream, ngx_uint_t do_write);
  72. static void
  73.     ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r);
  74. static void
  75.     ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  76.     ngx_http_upstream_t *u);
  77. static void
  78.     ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  79.     ngx_uint_t do_write);
  80. #if (NGX_THREADS)
  81. static ngx_int_t ngx_http_upstream_thread_handler(ngx_thread_task_t *task,
  82.     ngx_file_t *file);
  83. static void ngx_http_upstream_thread_event_handler(ngx_event_t *ev);
  84. #endif
  85. static ngx_int_t ngx_http_upstream_output_filter(void *data,
  86.     ngx_chain_t *chain);
  87. static void ngx_http_upstream_process_downstream(ngx_http_request_t *r);
  88. static void ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  89.     ngx_http_upstream_t *u);
  90. static void ngx_http_upstream_process_request(ngx_http_request_t *r,
  91.     ngx_http_upstream_t *u);
  92. static void ngx_http_upstream_store(ngx_http_request_t *r,
  93.     ngx_http_upstream_t *u);
  94. static void ngx_http_upstream_dummy_handler(ngx_http_request_t *r,
  95.     ngx_http_upstream_t *u);
  96. static void ngx_http_upstream_next(ngx_http_request_t *r,
  97.     ngx_http_upstream_t *u, ngx_uint_t ft_type);
  98. static void ngx_http_upstream_cleanup(void *data);
  99. static void ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  100.     ngx_http_upstream_t *u, ngx_int_t rc);

  102. static ngx_int_t ngx_http_upstream_process_header_line(ngx_http_request_t *r,
  103.     ngx_table_elt_t *h, ngx_uint_t offset);
  104. static ngx_int_t
  105.     ngx_http_upstream_process_multi_header_lines(ngx_http_request_t *r,
  106.     ngx_table_elt_t *h, ngx_uint_t offset);
  107. static ngx_int_t ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  108.     ngx_table_elt_t *h, ngx_uint_t offset);
  109. static ngx_int_t ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  110.     ngx_table_elt_t *h, ngx_uint_t offset);
  111. static ngx_int_t ngx_http_upstream_process_set_cookie(ngx_http_request_t *r,
  112.     ngx_table_elt_t *h, ngx_uint_t offset);
  113. static ngx_int_t
  114.     ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  115.     ngx_table_elt_t *h, ngx_uint_t offset);
  116. static ngx_int_t ngx_http_upstream_ignore_header_line(ngx_http_request_t *r,
  117.     ngx_table_elt_t *h, ngx_uint_t offset);
  118. static ngx_int_t ngx_http_upstream_process_expires(ngx_http_request_t *r,
  119.     ngx_table_elt_t *h, ngx_uint_t offset);
  120. static ngx_int_t ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  121.     ngx_table_elt_t *h, ngx_uint_t offset);
  122. static ngx_int_t ngx_http_upstream_process_limit_rate(ngx_http_request_t *r,
  123.     ngx_table_elt_t *h, ngx_uint_t offset);
  124. static ngx_int_t ngx_http_upstream_process_buffering(ngx_http_request_t *r,
  125.     ngx_table_elt_t *h, ngx_uint_t offset);
  126. static ngx_int_t ngx_http_upstream_process_charset(ngx_http_request_t *r,
  127.     ngx_table_elt_t *h, ngx_uint_t offset);
  128. static ngx_int_t ngx_http_upstream_process_connection(ngx_http_request_t *r,
  129.     ngx_table_elt_t *h, ngx_uint_t offset);
  130. static ngx_int_t
  131.     ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  132.     ngx_table_elt_t *h, ngx_uint_t offset);
  133. static ngx_int_t ngx_http_upstream_process_vary(ngx_http_request_t *r,
  134.     ngx_table_elt_t *h, ngx_uint_t offset);
  135. static ngx_int_t ngx_http_upstream_copy_header_line(ngx_http_request_t *r,
  136.     ngx_table_elt_t *h, ngx_uint_t offset);
  137. static ngx_int_t
  138.     ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  139.     ngx_table_elt_t *h, ngx_uint_t offset);
  140. static ngx_int_t ngx_http_upstream_copy_content_type(ngx_http_request_t *r,
  141.     ngx_table_elt_t *h, ngx_uint_t offset);
  142. static ngx_int_t ngx_http_upstream_copy_last_modified(ngx_http_request_t *r,
  143.     ngx_table_elt_t *h, ngx_uint_t offset);
  144. static ngx_int_t ngx_http_upstream_rewrite_location(ngx_http_request_t *r,
  145.     ngx_table_elt_t *h, ngx_uint_t offset);
  146. static ngx_int_t ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r,
  147.     ngx_table_elt_t *h, ngx_uint_t offset);
  148. static ngx_int_t ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r,
  149.     ngx_table_elt_t *h, ngx_uint_t offset);
  150. static ngx_int_t ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  151.     ngx_table_elt_t *h, ngx_uint_t offset);

  153. static ngx_int_t ngx_http_upstream_add_variables(ngx_conf_t *cf);
  154. static ngx_int_t ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  155.     ngx_http_variable_value_t *v, uintptr_t data);
  156. static ngx_int_t ngx_http_upstream_status_variable(ngx_http_request_t *r,
  157.     ngx_http_variable_value_t *v, uintptr_t data);
  158. static ngx_int_t ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  159.     ngx_http_variable_value_t *v, uintptr_t data);
  160. static ngx_int_t ngx_http_upstream_response_length_variable(
  161.     ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
  162. static ngx_int_t ngx_http_upstream_header_variable(ngx_http_request_t *r,
  163.     ngx_http_variable_value_t *v, uintptr_t data);
  164. static ngx_int_t ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  165.     ngx_http_variable_value_t *v, uintptr_t data);
  166. static ngx_int_t ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  167.     ngx_http_variable_value_t *v, uintptr_t data);

  169. static char *ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy);
  170. static char *ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd,
  171.     void *conf);
  172. #if (NGX_HTTP_UPSTREAM_ZONE)
  173. static char *ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  174.     void *conf);
  175. #endif

  177. static ngx_int_t ngx_http_upstream_set_local(ngx_http_request_t *r,
  178.   ngx_http_upstream_t *u, ngx_http_upstream_local_t *local);

  180. static void *ngx_http_upstream_create_main_conf(ngx_conf_t *cf);
  181. static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf);

  183. #if (NGX_HTTP_SSL)
  184. static void ngx_http_upstream_ssl_init_connection(ngx_http_request_t *,
  185.     ngx_http_upstream_t *u, ngx_connection_t *c);
  186. static void ngx_http_upstream_ssl_handshake_handler(ngx_connection_t *c);
  187. static void ngx_http_upstream_ssl_handshake(ngx_http_request_t *,
  188.     ngx_http_upstream_t *u, ngx_connection_t *c);
  189. static void ngx_http_upstream_ssl_save_session(ngx_connection_t *c);
  190. static ngx_int_t ngx_http_upstream_ssl_name(ngx_http_request_t *r,
  191.     ngx_http_upstream_t *u, ngx_connection_t *c);
  192. static ngx_int_t ngx_http_upstream_ssl_certificate(ngx_http_request_t *r,
  193.     ngx_http_upstream_t *u, ngx_connection_t *c);
  194. #endif


  197. ‌static ngx_http_upstream_header_t  ngx_http_upstream_headers_in[] = {

  199.     { ngx_string("Status"),
  200.                  ngx_http_upstream_process_header_line,
  201.                  offsetof(ngx_http_upstream_headers_in_t, status),
  202.                  ngx_http_upstream_copy_header_line, 0, 0 },

  204.     { ngx_string("Content-Type"),
  205.                  ngx_http_upstream_process_header_line,
  206.                  offsetof(ngx_http_upstream_headers_in_t, content_type),
  207.                  ngx_http_upstream_copy_content_type, 0, 1 },

  209.     { ngx_string("Content-Length"),
  210.                  ngx_http_upstream_process_content_length, 0,
  211.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  213.     { ngx_string("Date"),
  214.                  ngx_http_upstream_process_header_line,
  215.                  offsetof(ngx_http_upstream_headers_in_t, date),
  216.                  ngx_http_upstream_copy_header_line,
  217.                  offsetof(ngx_http_headers_out_t, date), 0 },

  219.     { ngx_string("Last-Modified"),
  220.                  ngx_http_upstream_process_last_modified, 0,
  221.                  ngx_http_upstream_copy_last_modified, 0, 0 },

  223.     { ngx_string("ETag"),
  224.                  ngx_http_upstream_process_header_line,
  225.                  offsetof(ngx_http_upstream_headers_in_t, etag),
  226.                  ngx_http_upstream_copy_header_line,
  227.                  offsetof(ngx_http_headers_out_t, etag), 0 },

  229.     { ngx_string("Server"),
  230.                  ngx_http_upstream_process_header_line,
  231.                  offsetof(ngx_http_upstream_headers_in_t, server),
  232.                  ngx_http_upstream_copy_header_line,
  233.                  offsetof(ngx_http_headers_out_t, server), 0 },

  235.     { ngx_string("WWW-Authenticate"),
  236.                  ngx_http_upstream_process_multi_header_lines,
  237.                  offsetof(ngx_http_upstream_headers_in_t, www_authenticate),
  238.                  ngx_http_upstream_copy_header_line, 0, 0 },

  240.     { ngx_string("Location"),
  241.                  ngx_http_upstream_process_header_line,
  242.                  offsetof(ngx_http_upstream_headers_in_t, location),
  243.                  ngx_http_upstream_rewrite_location, 0, 0 },

  245.     { ngx_string("Refresh"),
  246.                  ngx_http_upstream_process_header_line,
  247.                  offsetof(ngx_http_upstream_headers_in_t, refresh),
  248.                  ngx_http_upstream_rewrite_refresh, 0, 0 },

  250.     { ngx_string("Set-Cookie"),
  251.                  ngx_http_upstream_process_set_cookie,
  252.                  offsetof(ngx_http_upstream_headers_in_t, set_cookie),
  253.                  ngx_http_upstream_rewrite_set_cookie, 0, 1 },

  255.     { ngx_string("Content-Disposition"),
  256.                  ngx_http_upstream_ignore_header_line, 0,
  257.                  ngx_http_upstream_copy_header_line, 0, 1 },

  259.     { ngx_string("Cache-Control"),
  260.                  ngx_http_upstream_process_cache_control, 0,
  261.                  ngx_http_upstream_copy_multi_header_lines,
  262.                  offsetof(ngx_http_headers_out_t, cache_control), 1 },

  264.     { ngx_string("Expires"),
  265.                  ngx_http_upstream_process_expires, 0,
  266.                  ngx_http_upstream_copy_header_line,
  267.                  offsetof(ngx_http_headers_out_t, expires), 1 },

  269.     { ngx_string("Accept-Ranges"),
  270.                  ngx_http_upstream_ignore_header_line, 0,
  271.                  ngx_http_upstream_copy_allow_ranges,
  272.                  offsetof(ngx_http_headers_out_t, accept_ranges), 1 },

  274.     { ngx_string("Content-Range"),
  275.                  ngx_http_upstream_ignore_header_line, 0,
  276.                  ngx_http_upstream_copy_header_line,
  277.                  offsetof(ngx_http_headers_out_t, content_range), 0 },

  279.     { ngx_string("Connection"),
  280.                  ngx_http_upstream_process_connection, 0,
  281.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  283.     { ngx_string("Keep-Alive"),
  284.                  ngx_http_upstream_ignore_header_line, 0,
  285.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  287.     { ngx_string("Vary"),
  288.                  ngx_http_upstream_process_vary, 0,
  289.                  ngx_http_upstream_copy_header_line, 0, 0 },

  291.     { ngx_string("Link"),
  292.                  ngx_http_upstream_ignore_header_line, 0,
  293.                  ngx_http_upstream_copy_multi_header_lines,
  294.                  offsetof(ngx_http_headers_out_t, link), 0 },

  296.     { ngx_string("X-Accel-Expires"),
  297.                  ngx_http_upstream_process_accel_expires, 0,
  298.                  ngx_http_upstream_copy_header_line, 0, 0 },

  300.     { ngx_string("X-Accel-Redirect"),
  301.                  ngx_http_upstream_process_header_line,
  302.                  offsetof(ngx_http_upstream_headers_in_t, x_accel_redirect),
  303.                  ngx_http_upstream_copy_header_line, 0, 0 },

  305.     { ngx_string("X-Accel-Limit-Rate"),
  306.                  ngx_http_upstream_process_limit_rate, 0,
  307.                  ngx_http_upstream_copy_header_line, 0, 0 },

  309.     { ngx_string("X-Accel-Buffering"),
  310.                  ngx_http_upstream_process_buffering, 0,
  311.                  ngx_http_upstream_copy_header_line, 0, 0 },

  313.     { ngx_string("X-Accel-Charset"),
  314.                  ngx_http_upstream_process_charset, 0,
  315.                  ngx_http_upstream_copy_header_line, 0, 0 },

  317.     { ngx_string("Transfer-Encoding"),
  318.                  ngx_http_upstream_process_transfer_encoding, 0,
  319.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  321.     { ngx_string("Content-Encoding"),
  322.                  ngx_http_upstream_ignore_header_line, 0,
  323.                  ngx_http_upstream_copy_header_line,
  324.                  offsetof(ngx_http_headers_out_t, content_encoding), 0 },

  326.     { ngx_null_string, NULL, 0, NULL, 0, 0 }
  327. };


  330. ‌static ngx_command_t  ngx_http_upstream_commands[] = {

  332.     { ngx_string("upstream"),
  333.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
  334.       ngx_http_upstream,
  335.       0,
  336.       0,
  337.       NULL },

  339.     { ngx_string("server"),
  340.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  341.       ngx_http_upstream_server,
  342.       NGX_HTTP_SRV_CONF_OFFSET,
  343.       0,
  344.       NULL },

  346. #if (NGX_HTTP_UPSTREAM_ZONE)

  348.     { ngx_string("resolver"),
  349.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  350.       ngx_http_upstream_resolver,
  351.       NGX_HTTP_SRV_CONF_OFFSET,
  352.       0,
  353.       NULL },

  355.     { ngx_string("resolver_timeout"),
  356.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  357.       ngx_conf_set_msec_slot,
  358.       NGX_HTTP_SRV_CONF_OFFSET,
  359.       offsetof(ngx_http_upstream_srv_conf_t, resolver_timeout),
  360.       NULL },

  362. #endif

  364.       ngx_null_command
  365. };


  368. ‌static ngx_http_module_t  ngx_http_upstream_module_ctx = {
  369.     ngx_http_upstream_add_variables,       /* preconfiguration */
  370.     NULL,                                  /* postconfiguration */

  372.     ngx_http_upstream_create_main_conf,    /* create main configuration */
  373.     ngx_http_upstream_init_main_conf,      /* init main configuration */

  375.     NULL,                                  /* create server configuration */
  376.     NULL,                                  /* merge server configuration */

  378.     NULL,                                  /* create location configuration */
  379.     NULL                                   /* merge location configuration */
  380. };


  383. ‌ngx_module_t  ngx_http_upstream_module = {
  384.     NGX_MODULE_V1,
  385.     &ngx_http_upstream_module_ctx,         /* module context */
  386.     ngx_http_upstream_commands,            /* module directives */
  387.     NGX_HTTP_MODULE,                       /* module type */
  388.     NULL,                                  /* init master */
  389.     NULL,                                  /* init module */
  390.     NULL,                                  /* init process */
  391.     NULL,                                  /* init thread */
  392.     NULL,                                  /* exit thread */
  393.     NULL,                                  /* exit process */
  394.     NULL,                                  /* exit master */
  395.     NGX_MODULE_V1_PADDING
  396. };


  399. ‌static ngx_http_variable_t  ngx_http_upstream_vars[] = {

  401.     { ngx_string("upstream_addr"), NULL,
  402.       ngx_http_upstream_addr_variable, 0,
  403.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  405.     { ngx_string("upstream_status"), NULL,
  406.       ngx_http_upstream_status_variable, 0,
  407.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  409.     { ngx_string("upstream_connect_time"), NULL,
  410.       ngx_http_upstream_response_time_variable, 2,
  411.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  413.     { ngx_string("upstream_header_time"), NULL,
  414.       ngx_http_upstream_response_time_variable, 1,
  415.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  417.     { ngx_string("upstream_response_time"), NULL,
  418.       ngx_http_upstream_response_time_variable, 0,
  419.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  421.     { ngx_string("upstream_response_length"), NULL,
  422.       ngx_http_upstream_response_length_variable, 0,
  423.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  425.     { ngx_string("upstream_bytes_received"), NULL,
  426.       ngx_http_upstream_response_length_variable, 1,
  427.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  429.     { ngx_string("upstream_bytes_sent"), NULL,
  430.       ngx_http_upstream_response_length_variable, 2,
  431.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  433. #if (NGX_HTTP_CACHE)

  435.     { ngx_string("upstream_cache_status"), NULL,
  436.       ngx_http_upstream_cache_status, 0,
  437.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  439.     { ngx_string("upstream_cache_last_modified"), NULL,
  440.       ngx_http_upstream_cache_last_modified, 0,
  441.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  443.     { ngx_string("upstream_cache_etag"), NULL,
  444.       ngx_http_upstream_cache_etag, 0,
  445.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  447. #endif

  449.     { ngx_string("upstream_http_"), NULL, ngx_http_upstream_header_variable,
  450.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  452.     { ngx_string("upstream_trailer_"), NULL, ngx_http_upstream_trailer_variable,
  453.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  455.     { ngx_string("upstream_cookie_"), NULL, ngx_http_upstream_cookie_variable,
  456.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  458.       ngx_http_null_variable
  459. };


  462. ‌static ngx_http_upstream_next_t  ngx_http_upstream_next_errors[] = {
  463.     { 500, NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  464.     { 502, NGX_HTTP_UPSTREAM_FT_HTTP_502 },
  465.     { 503, NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  466.     { 504, NGX_HTTP_UPSTREAM_FT_HTTP_504 },
  467.     { 403, NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  468.     { 404, NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  469.     { 429, NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  470.     { 0, 0 }
  471. };


  474. ‌ngx_conf_bitmask_t  ngx_http_upstream_cache_method_mask[] = {
  475.     { ngx_string("GET"), NGX_HTTP_GET },
  476.     { ngx_string("HEAD"), NGX_HTTP_HEAD },
  477.     { ngx_string("POST"), NGX_HTTP_POST },
  478.     { ngx_null_string, 0 }
  479. };


  482. ‌ngx_conf_bitmask_t  ngx_http_upstream_ignore_headers_masks[] = {
  483.     { ngx_string("X-Accel-Redirect"), NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT },
  484.     { ngx_string("X-Accel-Expires"), NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES },
  485.     { ngx_string("X-Accel-Limit-Rate"), NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE },
  486.     { ngx_string("X-Accel-Buffering"), NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING },
  487.     { ngx_string("X-Accel-Charset"), NGX_HTTP_UPSTREAM_IGN_XA_CHARSET },
  488.     { ngx_string("Expires"), NGX_HTTP_UPSTREAM_IGN_EXPIRES },
  489.     { ngx_string("Cache-Control"), NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL },
  490.     { ngx_string("Set-Cookie"), NGX_HTTP_UPSTREAM_IGN_SET_COOKIE },
  491.     { ngx_string("Vary"), NGX_HTTP_UPSTREAM_IGN_VARY },
  492.     { ngx_null_string, 0 }
  493. };


  496. ngx_int_t
  497. ‌ngx_http_upstream_create(ngx_http_request_t *r)
  498. {
  499.     ngx_http_upstream_t  *u;

  501.     u = r->upstream;

  503.     if (u && u->cleanup) {
  504.         r->main->count++;
  505.         ngx_http_upstream_cleanup(r);
  506.     }

  508.     u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
  509.     if (u == NULL) {
  510.         return NGX_ERROR;
  511.     }

  513.     r->upstream = u;

  515.     u->peer.log = r->connection->log;
  516.     u->peer.log_error = NGX_ERROR_ERR;

  518. #if (NGX_HTTP_CACHE)
  519.     r->cache = NULL;
  520. #endif

  522.     u->headers_in.content_length_n = -1;
  523.     u->headers_in.last_modified_time = -1;

  525.     return NGX_OK;
  526. }


  529. void
  530. ‌ngx_http_upstream_init(ngx_http_request_t *r)
  531. {
  532.     ngx_connection_t     *c;

  534.     c = r->connection;

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

  539. #if (NGX_HTTP_V2)
  540.     if (r->stream) {
  541.         ngx_http_upstream_init_request(r);
  542.         return;
  543.     }
  544. #endif

  546. #if (NGX_HTTP_V3)
  547.     if (c->quic) {
  548.         ngx_http_upstream_init_request(r);
  549.         return;
  550.     }
  551. #endif

  553.     if (c->read->timer_set) {
  554.         ngx_del_timer(c->read);
  555.     }

  557.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  559.         if (!c->write->active) {
  560.             if (ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT)
  561.                 == NGX_ERROR)
  562.             {
  563.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  564.                 return;
  565.             }
  566.         }
  567.     }

  569.     ngx_http_upstream_init_request(r);
  570. }


  573. static void
  574. ‌ngx_http_upstream_init_request(ngx_http_request_t *r)
  575. {
  576.     ngx_str_t                      *host;
  577.     ngx_uint_t                      i;
  578.     ngx_resolver_ctx_t             *ctx, temp;
  579.     ngx_http_cleanup_t             *cln;
  580.     ngx_http_upstream_t            *u;
  581.     ngx_http_core_loc_conf_t       *clcf;
  582.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  583.     ngx_http_upstream_main_conf_t  *umcf;

  585.     if (r->aio) {
  586.         return;
  587.     }

  589.     u = r->upstream;

  591. #if (NGX_HTTP_CACHE)

  593.     if (u->conf->cache) {
  594.         ngx_int_t  rc;

  596.         rc = ngx_http_upstream_cache(r, u);

  598.         if (rc == NGX_BUSY) {
  599.             r->write_event_handler = ngx_http_upstream_init_request;
  600.             return;
  601.         }

  603.         r->write_event_handler = ngx_http_request_empty_handler;

  605.         if (rc == NGX_ERROR) {
  606.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  607.             return;
  608.         }

  610.         if (rc == NGX_OK) {
  611.             rc = ngx_http_upstream_cache_send(r, u);

  613.             if (rc == NGX_DONE) {
  614.                 return;
  615.             }

  617.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  618.                 rc = NGX_DECLINED;
  619.                 r->cached = 0;
  620.                 u->buffer.start = NULL;
  621.                 u->cache_status = NGX_HTTP_CACHE_MISS;
  622.                 u->request_sent = 1;
  623.             }
  624.         }

  626.         if (rc != NGX_DECLINED) {
  627.             ngx_http_finalize_request(r, rc);
  628.             return;
  629.         }
  630.     }

  632. #endif

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

  636.     if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {

  638.         if (r->connection->read->ready) {
  639.             ngx_post_event(r->connection->read, &ngx_posted_events);

  641.         } else {
  642.             if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  643.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  644.                 return;
  645.             }
  646.         }

  648.         r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;
  649.         r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
  650.     }

  652.     if (r->request_body) {
  653.         u->request_bufs = r->request_body->bufs;
  654.     }

  656.     if (u->create_request(r) != NGX_OK) {
  657.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  658.         return;
  659.     }

  661.     if (ngx_http_upstream_set_local(r, u, u->conf->local) != NGX_OK) {
  662.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  663.         return;
  664.     }

  666.     if (u->conf->socket_keepalive) {
  667.         u->peer.so_keepalive = 1;
  668.     }

  670.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  672.     u->output.alignment = clcf->directio_alignment;
  673.     u->output.pool = r->pool;
  674.     u->output.bufs.num = 1;
  675.     u->output.bufs.size = clcf->client_body_buffer_size;

  677.     if (u->output.output_filter == NULL) {
  678.         u->output.output_filter = ngx_chain_writer;
  679.         u->output.filter_ctx = &u->writer;
  680.     }

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

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

  686.         r->upstream_states = ngx_array_create(r->pool, 1,
  687.                                             sizeof(ngx_http_upstream_state_t));
  688.         if (r->upstream_states == NULL) {
  689.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  690.             return;
  691.         }

  693.     } else {

  695.         u->state = ngx_array_push(r->upstream_states);
  696.         if (u->state == NULL) {
  697.             ngx_http_upstream_finalize_request(r, u,
  698.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  699.             return;
  700.         }

  702.         ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
  703.     }

  705.     cln = ngx_http_cleanup_add(r, 0);
  706.     if (cln == NULL) {
  707.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  708.         return;
  709.     }

  711.     cln->handler = ngx_http_upstream_cleanup;
  712.     cln->data = r;
  713.     u->cleanup = &cln->handler;

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

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

  719.     } else {

  721. #if (NGX_HTTP_SSL)
  722.         u->ssl_name = u->resolved->host;
  723. #endif

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

  727.         umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  729.         uscfp = umcf->upstreams.elts;

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

  733.             uscf = uscfp[i];

  735.             if (uscf->host.len == host->len
  736.                 && ((uscf->port == 0 && u->resolved->no_port)
  737.                      || uscf->port == u->resolved->port)
  738.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  739.             {
  740.                 goto found;
  741.             }
  742.         }

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

  746.             if (u->resolved->port == 0
  747.                 && u->resolved->sockaddr->sa_family != AF_UNIX)
  748.             {
  749.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  750.                               "no port in upstream \"%V\"", host);
  751.                 ngx_http_upstream_finalize_request(r, u,
  752.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  753.                 return;
  754.             }

  756.             if (ngx_http_upstream_create_round_robin_peer(r, u->resolved)
  757.                 != NGX_OK)
  758.             {
  759.                 ngx_http_upstream_finalize_request(r, u,
  760.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  761.                 return;
  762.             }

  764.             ngx_http_upstream_connect(r, u);

  766.             return;
  767.         }

  769.         if (u->resolved->port == 0) {
  770.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  771.                           "no port in upstream \"%V\"", host);
  772.             ngx_http_upstream_finalize_request(r, u,
  773.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  774.             return;
  775.         }

  777.         temp.name = *host;

  779.         ctx = ngx_resolve_start(clcf->resolver, &temp);
  780.         if (ctx == NULL) {
  781.             ngx_http_upstream_finalize_request(r, u,
  782.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  783.             return;
  784.         }

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

  790.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  791.             return;
  792.         }

  794.         ctx->name = *host;
  795.         ctx->handler = ngx_http_upstream_resolve_handler;
  796.         ctx->data = r;
  797.         ctx->timeout = clcf->resolver_timeout;

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

  801.         if (ngx_resolve_name(ctx) != NGX_OK) {
  802.             u->resolved->ctx = NULL;
  803.             ngx_http_upstream_finalize_request(r, u,
  804.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  805.             return;
  806.         }

  808.         return;
  809.     }

  811. found:

  813.     if (uscf == NULL) {
  814.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  815.                       "no upstream configuration");
  816.         ngx_http_upstream_finalize_request(r, u,
  817.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  818.         return;
  819.     }

  821.     u->upstream = uscf;

  823. #if (NGX_HTTP_SSL)
  824.     u->ssl_name = uscf->host;
  825. #endif

  827.     if (uscf->peer.init(r, uscf) != NGX_OK) {
  828.         ngx_http_upstream_finalize_request(r, u,
  829.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  830.         return;
  831.     }

  833.     u->peer.start_time = ngx_current_msec;

  835.     if (u->conf->next_upstream_tries
  836.         && u->peer.tries > u->conf->next_upstream_tries)
  837.     {
  838.         u->peer.tries = u->conf->next_upstream_tries;
  839.     }

  841.     ngx_http_upstream_connect(r, u);
  842. }


  845. #if (NGX_HTTP_CACHE)

  847. static ngx_int_t
  848. ‌ngx_http_upstream_cache(ngx_http_request_t *r, ngx_http_upstream_t *u)
  849. {
  850.     ngx_int_t               rc;
  851.     ngx_http_cache_t       *c;
  852.     ngx_http_file_cache_t  *cache;

  854.     c = r->cache;

  856.     if (c == NULL) {

  858.         if (!(r->method & u->conf->cache_methods)) {
  859.             return NGX_DECLINED;
  860.         }

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

  864.         if (rc != NGX_OK) {
  865.             return rc;
  866.         }

  868.         if (r->method == NGX_HTTP_HEAD && u->conf->cache_convert_head) {
  869.             u->method = ngx_http_core_get_method;
  870.         }

  872.         if (ngx_http_file_cache_new(r) != NGX_OK) {
  873.             return NGX_ERROR;
  874.         }

  876.         if (u->create_key(r) != NGX_OK) {
  877.             return NGX_ERROR;
  878.         }

  880.         /* TODO: add keys */

  882.         ngx_http_file_cache_create_key(r);

  884.         if (r->cache->header_start + 256 > u->conf->buffer_size) {
  885.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  886.                           "%V_buffer_size %uz is not enough for cache key, "
  887.                           "it should be increased to at least %uz",
  888.                           &u->conf->module, u->conf->buffer_size,
  889.                           ngx_align(r->cache->header_start + 256, 1024));

  891.             r->cache = NULL;
  892.             return NGX_DECLINED;
  893.         }

  895.         u->cacheable = 1;

  897.         c = r->cache;

  899.         c->body_start = u->conf->buffer_size;
  900.         c->min_uses = u->conf->cache_min_uses;
  901.         c->file_cache = cache;

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

  905.         case NGX_ERROR:
  906.             return NGX_ERROR;

  908.         case NGX_DECLINED:
  909.             u->cache_status = NGX_HTTP_CACHE_BYPASS;
  910.             return NGX_DECLINED;

  912.         default: /* NGX_OK */
  913.             break;
  914.         }

  916.         c->lock = u->conf->cache_lock;
  917.         c->lock_timeout = u->conf->cache_lock_timeout;
  918.         c->lock_age = u->conf->cache_lock_age;

  920.         u->cache_status = NGX_HTTP_CACHE_MISS;
  921.     }

  923.     rc = ngx_http_file_cache_open(r);

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

  928.     switch (rc) {

  930.     case NGX_HTTP_CACHE_STALE:

  932.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  933.              || c->stale_updating) && !r->background
  934.             && u->conf->cache_background_update)
  935.         {
  936.             if (ngx_http_upstream_cache_background_update(r, u) == NGX_OK) {
  937.                 r->cache->background = 1;
  938.                 u->cache_status = rc;
  939.                 rc = NGX_OK;

  941.             } else {
  942.                 rc = NGX_ERROR;
  943.             }
  944.         }

  946.         break;

  948.     case NGX_HTTP_CACHE_UPDATING:

  950.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  951.              || c->stale_updating) && !r->background)
  952.         {
  953.             u->cache_status = rc;
  954.             rc = NGX_OK;

  956.         } else {
  957.             rc = NGX_HTTP_CACHE_STALE;
  958.         }

  960.         break;

  962.     case NGX_OK:
  963.         u->cache_status = NGX_HTTP_CACHE_HIT;
  964.     }

  966.     switch (rc) {

  968.     case NGX_OK:

  970.         return NGX_OK;

  972.     case NGX_HTTP_CACHE_STALE:

  974.         c->valid_sec = 0;
  975.         c->updating_sec = 0;
  976.         c->error_sec = 0;

  978.         u->buffer.start = NULL;
  979.         u->cache_status = NGX_HTTP_CACHE_EXPIRED;

  981.         break;

  983.     case NGX_DECLINED:

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

  988.         } else {
  989.             u->buffer.pos = u->buffer.start + c->header_start;
  990.             u->buffer.last = u->buffer.pos;
  991.         }

  993.         break;

  995.     case NGX_HTTP_CACHE_SCARCE:

  997.         u->cacheable = 0;

  999.         break;

  1001.     case NGX_AGAIN:

  1003.         return NGX_BUSY;

  1005.     case NGX_ERROR:

  1007.         return NGX_ERROR;

  1009.     default:

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

  1013.         u->cache_status = NGX_HTTP_CACHE_HIT;

  1015.         return rc;
  1016.     }

  1018.     if (ngx_http_upstream_cache_check_range(r, u) == NGX_DECLINED) {
  1019.         u->cacheable = 0;
  1020.     }

  1022.     r->cached = 0;

  1024.     return NGX_DECLINED;
  1025. }


  1028. static ngx_int_t
  1029. ‌ngx_http_upstream_cache_get(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1030.     ngx_http_file_cache_t **cache)
  1031. {
  1032.     ngx_str_t               *name, val;
  1033.     ngx_uint_t               i;
  1034.     ngx_http_file_cache_t  **caches;

  1036.     if (u->conf->cache_zone) {
  1037.         *cache = u->conf->cache_zone->data;
  1038.         return NGX_OK;
  1039.     }

  1041.     if (ngx_http_complex_value(r, u->conf->cache_value, &val) != NGX_OK) {
  1042.         return NGX_ERROR;
  1043.     }

  1045.     if (val.len == 0
  1046.         || (val.len == 3 && ngx_strncmp(val.data, "off", 3) == 0))
  1047.     {
  1048.         return NGX_DECLINED;
  1049.     }

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

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

  1056.         if (name->len == val.len
  1057.             && ngx_strncmp(name->data, val.data, val.len) == 0)
  1058.         {
  1059.             *cache = caches[i];
  1060.             return NGX_OK;
  1061.         }
  1062.     }

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

  1067.     return NGX_ERROR;
  1068. }


  1071. static ngx_int_t
  1072. ‌ngx_http_upstream_cache_send(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1073. {
  1074.     ngx_int_t          rc;
  1075.     ngx_http_cache_t  *c;

  1077.     r->cached = 1;
  1078.     c = r->cache;

  1080.     if (c->header_start == c->body_start) {
  1081.         r->http_version = NGX_HTTP_VERSION_9;
  1082.         return ngx_http_cache_send(r);
  1083.     }

  1085.     /* TODO: cache stack */

  1087.     u->buffer = *c->buf;
  1088.     u->buffer.pos += c->header_start;

  1090.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  1091.     u->headers_in.content_length_n = -1;
  1092.     u->headers_in.last_modified_time = -1;

  1094.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  1095.                       sizeof(ngx_table_elt_t))
  1096.         != NGX_OK)
  1097.     {
  1098.         return NGX_ERROR;
  1099.     }

  1101.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  1102.                       sizeof(ngx_table_elt_t))
  1103.         != NGX_OK)
  1104.     {
  1105.         return NGX_ERROR;
  1106.     }

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

  1110.     if (rc == NGX_OK) {

  1112.         if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  1113.             return NGX_DONE;
  1114.         }

  1116.         return ngx_http_cache_send(r);
  1117.     }

  1119.     if (rc == NGX_ERROR) {
  1120.         return NGX_ERROR;
  1121.     }

  1123.     if (rc == NGX_AGAIN) {
  1124.         rc = NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1125.     }

  1127.     /* rc == NGX_HTTP_UPSTREAM_INVALID_HEADER */

  1129.     ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1130.                   "cache file \"%s\" contains invalid header",
  1131.                   c->file.name.data);

  1133.     /* TODO: delete file */

  1135.     return rc;
  1136. }


  1139. static ngx_int_t
  1140. ‌ngx_http_upstream_cache_background_update(ngx_http_request_t *r,
  1141.     ngx_http_upstream_t *u)
  1142. {
  1143.     ngx_http_request_t  *sr;

  1145.     if (r == r->main) {
  1146.         r->preserve_body = 1;
  1147.     }

  1149.     if (ngx_http_subrequest(r, &r->uri, &r->args, &sr, NULL,
  1150.                             NGX_HTTP_SUBREQUEST_CLONE
  1151.                             |NGX_HTTP_SUBREQUEST_BACKGROUND)
  1152.         != NGX_OK)
  1153.     {
  1154.         return NGX_ERROR;
  1155.     }

  1157.     sr->header_only = 1;

  1159.     return NGX_OK;
  1160. }


  1163. static ngx_int_t
  1164. ‌ngx_http_upstream_cache_check_range(ngx_http_request_t *r,
  1165.     ngx_http_upstream_t *u)
  1166. {
  1167.     off_t             offset;
  1168.     u_char           *p, *start;
  1169.     ngx_table_elt_t  *h;

  1171.     h = r->headers_in.range;

  1173.     if (h == NULL
  1174.         || !u->cacheable
  1175.         || u->conf->cache_max_range_offset == NGX_MAX_OFF_T_VALUE)
  1176.     {
  1177.         return NGX_OK;
  1178.     }

  1180.     if (u->conf->cache_max_range_offset == 0) {
  1181.         return NGX_DECLINED;
  1182.     }

  1184.     if (h->value.len < 7
  1185.         || ngx_strncasecmp(h->value.data, (u_char *) "bytes=", 6) != 0)
  1186.     {
  1187.         return NGX_OK;
  1188.     }

  1190.     p = h->value.data + 6;

  1192.     while (*p == ' ') { p++; }

  1194.     if (*p == '-') {
  1195.         return NGX_DECLINED;
  1196.     }

  1198.     start = p;

  1200.     while (*p >= '0' && *p <= '9') { p++; }

  1202.     offset = ngx_atoof(start, p - start);

  1204.     if (offset >= u->conf->cache_max_range_offset) {
  1205.         return NGX_DECLINED;
  1206.     }

  1208.     return NGX_OK;
  1209. }

  1211. #endif


  1214. static void
  1215. ‌ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
  1216. {
  1217.     ngx_uint_t                     run_posted;
  1218.     ngx_connection_t              *c;
  1219.     ngx_http_request_t            *r;
  1220.     ngx_http_upstream_t           *u;
  1221.     ngx_http_upstream_resolved_t  *ur;

  1223.     run_posted = ctx->async;

  1225.     r = ctx->data;
  1226.     c = r->connection;

  1228.     u = r->upstream;
  1229.     ur = u->resolved;

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

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

  1236.     if (ctx->state) {
  1237.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1238.                       "%V could not be resolved (%i: %s)",
  1239.                       &ctx->name, ctx->state,
  1240.                       ngx_resolver_strerror(ctx->state));

  1242.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  1243.         goto failed;
  1244.     }

  1246.     ur->naddrs = ctx->naddrs;
  1247.     ur->addrs = ctx->addrs;

  1249. #if (NGX_DEBUG)
  1250.     {
  1251.     u_char      text[NGX_SOCKADDR_STRLEN];
  1252.     ngx_str_t   addr;
  1253.     ngx_uint_t  i;

  1255.     addr.data = text;

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

  1261.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1262.                        "name was resolved to %V", &addr);
  1263.     }
  1264.     }
  1265. #endif

  1267.     if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
  1268.         ngx_http_upstream_finalize_request(r, u,
  1269.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1270.         goto failed;
  1271.     }

  1273.     ngx_resolve_name_done(ctx);
  1274.     ur->ctx = NULL;

  1276.     u->peer.start_time = ngx_current_msec;

  1278.     if (u->conf->next_upstream_tries
  1279.         && u->peer.tries > u->conf->next_upstream_tries)
  1280.     {
  1281.         u->peer.tries = u->conf->next_upstream_tries;
  1282.     }

  1284.     ngx_http_upstream_connect(r, u);

  1286. failed:

  1288.     if (run_posted) {
  1289.         ngx_http_run_posted_requests(c);
  1290.     }
  1291. }


  1294. static void
  1295. ‌ngx_http_upstream_handler(ngx_event_t *ev)
  1296. {
  1297.     ngx_connection_t     *c;
  1298.     ngx_http_request_t   *r;
  1299.     ngx_http_upstream_t  *u;

  1301.     c = ev->data;
  1302.     r = c->data;

  1304.     u = r->upstream;
  1305.     c = r->connection;

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

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

  1312.     if (ev->delayed && ev->timedout) {
  1313.         ev->delayed = 0;
  1314.         ev->timedout = 0;
  1315.     }

  1317.     if (ev->write) {
  1318.         u->write_event_handler(r, u);

  1320.     } else {
  1321.         u->read_event_handler(r, u);
  1322.     }

  1324.     ngx_http_run_posted_requests(c);
  1325. }


  1328. static void
  1329. ‌ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r)
  1330. {
  1331.     ngx_http_upstream_check_broken_connection(r, r->connection->read);
  1332. }


  1335. static void
  1336. ‌ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r)
  1337. {
  1338.     ngx_http_upstream_check_broken_connection(r, r->connection->write);
  1339. }


  1342. static void
  1343. ‌ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  1344.     ngx_event_t *ev)
  1345. {
  1346.     int                  n;
  1347.     char                 buf[1];
  1348.     ngx_err_t            err;
  1349.     ngx_int_t            event;
  1350.     ngx_connection_t     *c;
  1351.     ngx_http_upstream_t  *u;

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

  1357.     c = r->connection;
  1358.     u = r->upstream;

  1360.     if (c->error) {
  1361.         if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {

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

  1365.             if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1366.                 ngx_http_upstream_finalize_request(r, u,
  1367.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1368.                 return;
  1369.             }
  1370.         }

  1372.         if (!u->cacheable) {
  1373.             ngx_http_upstream_finalize_request(r, u,
  1374.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1375.         }

  1377.         return;
  1378.     }

  1380. #if (NGX_HTTP_V2)
  1381.     if (r->stream) {
  1382.         return;
  1383.     }
  1384. #endif

  1386. #if (NGX_HTTP_V3)

  1388.     if (c->quic) {
  1389.         if (c->write->error) {
  1390.             ngx_http_upstream_finalize_request(r, u,
  1391.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1392.         }

  1394.         return;
  1395.     }

  1397. #endif

  1399. #if (NGX_HAVE_KQUEUE)

  1401.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  1403.         if (!ev->pending_eof) {
  1404.             return;
  1405.         }

  1407.         ev->eof = 1;
  1408.         c->error = 1;

  1410.         if (ev->kq_errno) {
  1411.             ev->error = 1;
  1412.         }

  1414.         if (!u->cacheable && u->peer.connection) {
  1415.             ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1416.                           "kevent() reported that client prematurely closed "
  1417.                           "connection, so upstream connection is closed too");
  1418.             ngx_http_upstream_finalize_request(r, u,
  1419.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1420.             return;
  1421.         }

  1423.         ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1424.                       "kevent() reported that client prematurely closed "
  1425.                       "connection");

  1427.         if (u->peer.connection == NULL) {
  1428.             ngx_http_upstream_finalize_request(r, u,
  1429.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1430.         }

  1432.         return;
  1433.     }

  1435. #endif

  1437. #if (NGX_HAVE_EPOLLRDHUP)

  1439.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  1440.         socklen_t  len;

  1442.         if (!ev->pending_eof) {
  1443.             return;
  1444.         }

  1446.         ev->eof = 1;
  1447.         c->error = 1;

  1449.         err = 0;
  1450.         len = sizeof(ngx_err_t);

  1452.         /*
  1453.          * BSDs and Linux return 0 and set a pending error in err
  1454.          * Solaris returns -1 and sets errno
  1455.          */

  1457.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1458.             == -1)
  1459.         {
  1460.             err = ngx_socket_errno;
  1461.         }

  1463.         if (err) {
  1464.             ev->error = 1;
  1465.         }

  1467.         if (!u->cacheable && u->peer.connection) {
  1468.             ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1469.                         "epoll_wait() reported that client prematurely closed "
  1470.                         "connection, so upstream connection is closed too");
  1471.             ngx_http_upstream_finalize_request(r, u,
  1472.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1473.             return;
  1474.         }

  1476.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1477.                       "epoll_wait() reported that client prematurely closed "
  1478.                       "connection");

  1480.         if (u->peer.connection == NULL) {
  1481.             ngx_http_upstream_finalize_request(r, u,
  1482.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1483.         }

  1485.         return;
  1486.     }

  1488. #endif

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

  1492.     err = ngx_socket_errno;

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

  1497.     if (ev->write && (n >= 0 || err == NGX_EAGAIN)) {
  1498.         return;
  1499.     }

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

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

  1505.         if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1506.             ngx_http_upstream_finalize_request(r, u,
  1507.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1508.             return;
  1509.         }
  1510.     }

  1512.     if (n > 0) {
  1513.         return;
  1514.     }

  1516.     if (n == -1) {
  1517.         if (err == NGX_EAGAIN) {
  1518.             return;
  1519.         }

  1521.         ev->error = 1;

  1523.     } else { /* n == 0 */
  1524.         err = 0;
  1525.     }

  1527.     ev->eof = 1;
  1528.     c->error = 1;

  1530.     if (!u->cacheable && u->peer.connection) {
  1531.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1532.                       "client prematurely closed connection, "
  1533.                       "so upstream connection is closed too");
  1534.         ngx_http_upstream_finalize_request(r, u,
  1535.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1536.         return;
  1537.     }

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

  1542.     if (u->peer.connection == NULL) {
  1543.         ngx_http_upstream_finalize_request(r, u,
  1544.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1545.     }
  1546. }


  1549. static void
  1550. ‌ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1551. {
  1552.     ngx_int_t                  rc;
  1553.     ngx_connection_t          *c;
  1554.     ngx_http_core_loc_conf_t  *clcf;

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

  1558.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  1559.         u->state->response_time = ngx_current_msec - u->start_time;
  1560.     }

  1562.     u->state = ngx_array_push(r->upstream_states);
  1563.     if (u->state == NULL) {
  1564.         ngx_http_upstream_finalize_request(r, u,
  1565.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1566.         return;
  1567.     }

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

  1571.     u->start_time = ngx_current_msec;

  1573.     u->state->response_time = (ngx_msec_t) -1;
  1574.     u->state->connect_time = (ngx_msec_t) -1;
  1575.     u->state->header_time = (ngx_msec_t) -1;

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

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

  1582.     if (rc == NGX_ERROR) {
  1583.         ngx_http_upstream_finalize_request(r, u,
  1584.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1585.         return;
  1586.     }

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

  1590. #if (NGX_HTTP_UPSTREAM_ZONE)
  1591.     if (u->upstream && u->upstream->shm_zone
  1592.         && (u->upstream->flags & NGX_HTTP_UPSTREAM_MODIFY))
  1593.     {
  1594.         u->state->peer = ngx_palloc(r->pool,
  1595.                                     sizeof(ngx_str_t) + u->peer.name->len);
  1596.         if (u->state->peer == NULL) {
  1597.             ngx_http_upstream_finalize_request(r, u,
  1598.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1599.             return;
  1600.         }

  1602.         u->state->peer->len = u->peer.name->len;
  1603.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  1604.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  1606.         u->peer.name = u->state->peer;
  1607.     }
  1608. #endif

  1610.     if (rc == NGX_BUSY) {
  1611.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
  1612.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);
  1613.         return;
  1614.     }

  1616.     if (rc == NGX_DECLINED) {
  1617.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1618.         return;
  1619.     }

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

  1623.     c = u->peer.connection;

  1625.     c->requests++;

  1627.     c->data = r;

  1629.     c->write->handler = ngx_http_upstream_handler;
  1630.     c->read->handler = ngx_http_upstream_handler;

  1632.     u->write_event_handler = ngx_http_upstream_send_request_handler;
  1633.     u->read_event_handler = ngx_http_upstream_process_header;

  1635.     c->sendfile &= r->connection->sendfile;
  1636.     u->output.sendfile = c->sendfile;

  1638.     if (r->connection->tcp_nopush == NGX_TCP_NOPUSH_DISABLED) {
  1639.         c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1640.     }

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

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

  1646.         c->pool = ngx_create_pool(128, r->connection->log);
  1647.         if (c->pool == NULL) {
  1648.             ngx_http_upstream_finalize_request(r, u,
  1649.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1650.             return;
  1651.         }
  1652.     }

  1654.     c->log = r->connection->log;
  1655.     c->pool->log = c->log;
  1656.     c->read->log = c->log;
  1657.     c->write->log = c->log;

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

  1661.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1663.     u->writer.out = NULL;
  1664.     u->writer.last = &u->writer.out;
  1665.     u->writer.connection = c;
  1666.     u->writer.limit = clcf->sendfile_max_chunk;

  1668.     if (u->request_sent) {
  1669.         if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
  1670.             ngx_http_upstream_finalize_request(r, u,
  1671.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1672.             return;
  1673.         }
  1674.     }

  1676.     if (r->request_body
  1677.         && r->request_body->buf
  1678.         && r->request_body->temp_file
  1679.         && r == r->main)
  1680.     {
  1681.         /*
  1682.          * the r->request_body->buf can be reused for one request only,
  1683.          * the subrequests should allocate their own temporary bufs
  1684.          */

  1686.         u->output.free = ngx_alloc_chain_link(r->pool);
  1687.         if (u->output.free == NULL) {
  1688.             ngx_http_upstream_finalize_request(r, u,
  1689.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1690.             return;
  1691.         }

  1693.         u->output.free->buf = r->request_body->buf;
  1694.         u->output.free->next = NULL;
  1695.         u->output.allocated = 1;

  1697.         r->request_body->buf->pos = r->request_body->buf->start;
  1698.         r->request_body->buf->last = r->request_body->buf->start;
  1699.         r->request_body->buf->tag = u->output.tag;
  1700.     }

  1702.     u->request_sent = 0;
  1703.     u->request_body_sent = 0;
  1704.     u->request_body_blocked = 0;

  1706.     if (rc == NGX_AGAIN) {
  1707.         ngx_add_timer(c->write, u->conf->connect_timeout);
  1708.         return;
  1709.     }

  1711. #if (NGX_HTTP_SSL)

  1713.     if (u->ssl && c->ssl == NULL) {
  1714.         ngx_http_upstream_ssl_init_connection(r, u, c);
  1715.         return;
  1716.     }

  1718. #endif

  1720.     ngx_http_upstream_send_request(r, u, 1);
  1721. }


  1724. #if (NGX_HTTP_SSL)

  1726. static void
  1727. ‌ngx_http_upstream_ssl_init_connection(ngx_http_request_t *r,
  1728.     ngx_http_upstream_t *u, ngx_connection_t *c)
  1729. {
  1730.     ngx_int_t                  rc;
  1731.     ngx_http_core_loc_conf_t  *clcf;

  1733.     if (ngx_http_upstream_test_connect(c) != NGX_OK) {
  1734.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1735.         return;
  1736.     }

  1738.     if (ngx_ssl_create_connection(u->conf->ssl, c,
  1739.                                   NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1740.         != NGX_OK)
  1741.     {
  1742.         ngx_http_upstream_finalize_request(r, u,
  1743.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1744.         return;
  1745.     }

  1747.     if (u->conf->ssl_server_name || u->conf->ssl_verify) {
  1748.         if (ngx_http_upstream_ssl_name(r, u, c) != NGX_OK) {
  1749.             ngx_http_upstream_finalize_request(r, u,
  1750.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1751.             return;
  1752.         }
  1753.     }

  1755.     if (u->conf->ssl_certificate
  1756.         && u->conf->ssl_certificate->value.len
  1757.         && (u->conf->ssl_certificate->lengths
  1758.             || u->conf->ssl_certificate_key->lengths))
  1759.     {
  1760.         if (ngx_http_upstream_ssl_certificate(r, u, c) != NGX_OK) {
  1761.             ngx_http_upstream_finalize_request(r, u,
  1762.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1763.             return;
  1764.         }
  1765.     }

  1767.     if (u->conf->ssl_session_reuse) {
  1768.         c->ssl->save_session = ngx_http_upstream_ssl_save_session;

  1770.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1771.             ngx_http_upstream_finalize_request(r, u,
  1772.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1773.             return;
  1774.         }

  1776.         /* abbreviated SSL handshake may interact badly with Nagle */

  1778.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1780.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  1781.             ngx_http_upstream_finalize_request(r, u,
  1782.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1783.             return;
  1784.         }
  1785.     }

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

  1789.     rc = ngx_ssl_handshake(c);

  1791.     if (rc == NGX_AGAIN) {

  1793.         if (!c->write->timer_set) {
  1794.             ngx_add_timer(c->write, u->conf->connect_timeout);
  1795.         }

  1797.         c->ssl->handler = ngx_http_upstream_ssl_handshake_handler;
  1798.         return;
  1799.     }

  1801.     ngx_http_upstream_ssl_handshake(r, u, c);
  1802. }


  1805. static void
  1806. ‌ngx_http_upstream_ssl_handshake_handler(ngx_connection_t *c)
  1807. {
  1808.     ngx_http_request_t   *r;
  1809.     ngx_http_upstream_t  *u;

  1811.     r = c->data;

  1813.     u = r->upstream;
  1814.     c = r->connection;

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

  1818.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  1819.                    "http upstream ssl handshake: \"%V?%V\"",
  1820.                    &r->uri, &r->args);

  1822.     ngx_http_upstream_ssl_handshake(r, u, u->peer.connection);

  1824.     ngx_http_run_posted_requests(c);
  1825. }


  1828. static void
  1829. ‌ngx_http_upstream_ssl_handshake(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1830.     ngx_connection_t *c)
  1831. {
  1832.     long  rc;

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

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

  1839.             if (rc != X509_V_OK) {
  1840.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1841.                               "upstream SSL certificate verify error: (%l:%s)",
  1842.                               rc, X509_verify_cert_error_string(rc));
  1843.                 goto failed;
  1844.             }

  1846.             if (ngx_ssl_check_host(c, &u->ssl_name) != NGX_OK) {
  1847.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1848.                               "upstream SSL certificate does not match \"%V\"",
  1849.                               &u->ssl_name);
  1850.                 goto failed;
  1851.             }
  1852.         }

  1854.         if (!c->ssl->sendfile) {
  1855.             c->sendfile = 0;
  1856.             u->output.sendfile = 0;
  1857.         }

  1859.         c->write->handler = ngx_http_upstream_handler;
  1860.         c->read->handler = ngx_http_upstream_handler;

  1862.         ngx_http_upstream_send_request(r, u, 1);

  1864.         return;
  1865.     }

  1867.     if (c->write->timedout) {
  1868.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  1869.         return;
  1870.     }

  1872. failed:

  1874.     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1875. }


  1878. static void
  1879. ‌ngx_http_upstream_ssl_save_session(ngx_connection_t *c)
  1880. {
  1881.     ngx_http_request_t   *r;
  1882.     ngx_http_upstream_t  *u;

  1884.     if (c->idle) {
  1885.         return;
  1886.     }

  1888.     r = c->data;

  1890.     u = r->upstream;
  1891.     c = r->connection;

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

  1895.     u->peer.save_session(&u->peer, u->peer.data);
  1896. }


  1899. static ngx_int_t
  1900. ‌ngx_http_upstream_ssl_name(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1901.     ngx_connection_t *c)
  1902. {
  1903.     u_char     *p, *last;
  1904.     ngx_str_t   name;

  1906.     if (u->conf->ssl_name) {
  1907.         if (ngx_http_complex_value(r, u->conf->ssl_name, &name) != NGX_OK) {
  1908.             return NGX_ERROR;
  1909.         }

  1911.     } else {
  1912.         name = u->ssl_name;
  1913.     }

  1915.     if (name.len == 0) {
  1916.         goto done;
  1917.     }

  1919.     /*
  1920.      * ssl name here may contain port, notably if derived from $proxy_host
  1921.      * or $http_host; we have to strip it
  1922.      */

  1924.     p = name.data;
  1925.     last = name.data + name.len;

  1927.     if (*p == '[') {
  1928.         p = ngx_strlchr(p, last, ']');

  1930.         if (p == NULL) {
  1931.             p = name.data;
  1932.         }
  1933.     }

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

  1937.     if (p != NULL) {
  1938.         name.len = p - name.data;
  1939.     }

  1941.     if (!u->conf->ssl_server_name) {
  1942.         goto done;
  1943.     }

  1945. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  1949.     if (name.len == 0 || *name.data == '[') {
  1950.         goto done;
  1951.     }

  1953.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1954.         goto done;
  1955.     }

  1957.     /*
  1958.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1959.      * hence we explicitly null-terminate name here
  1960.      */

  1962.     p = ngx_pnalloc(r->pool, name.len + 1);
  1963.     if (p == NULL) {
  1964.         return NGX_ERROR;
  1965.     }

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

  1969.     name.data = p;

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

  1974.     if (SSL_set_tlsext_host_name(c->ssl->connection,
  1975.                                  (char *) name.data)
  1976.         == 0)
  1977.     {
  1978.         ngx_ssl_error(NGX_LOG_ERR, r->connection->log, 0,
  1979.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  1980.         return NGX_ERROR;
  1981.     }

  1983. #endif

  1985. done:

  1987.     u->ssl_name = name;

  1989.     return NGX_OK;
  1990. }


  1993. static ngx_int_t
  1994. ‌ngx_http_upstream_ssl_certificate(ngx_http_request_t *r,
  1995.     ngx_http_upstream_t *u, ngx_connection_t *c)
  1996. {
  1997.     ngx_str_t  cert, key;

  1999.     if (ngx_http_complex_value(r, u->conf->ssl_certificate, &cert)
  2000.         != NGX_OK)
  2001.     {
  2002.         return NGX_ERROR;
  2003.     }

  2005.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2006.                    "http upstream ssl cert: \"%s\"", cert.data);

  2008.     if (*cert.data == '\0') {
  2009.         return NGX_OK;
  2010.     }

  2012.     if (ngx_http_complex_value(r, u->conf->ssl_certificate_key, &key)
  2013.         != NGX_OK)
  2014.     {
  2015.         return NGX_ERROR;
  2016.     }

  2018.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2019.                    "http upstream ssl key: \"%s\"", key.data);

  2021.     if (ngx_ssl_connection_certificate(c, r->pool, &cert, &key,
  2022.                                        u->conf->ssl_passwords)
  2023.         != NGX_OK)
  2024.     {
  2025.         return NGX_ERROR;
  2026.     }

  2028.     return NGX_OK;
  2029. }

  2031. #endif


  2034. static ngx_int_t
  2035. ‌ngx_http_upstream_reinit(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2036. {
  2037.     off_t         file_pos;
  2038.     ngx_chain_t  *cl;

  2040.     if (u->reinit_request(r) != NGX_OK) {
  2041.         return NGX_ERROR;
  2042.     }

  2044.     u->keepalive = 0;
  2045.     u->upgrade = 0;
  2046.     u->error = 0;

  2048.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2049.     u->headers_in.content_length_n = -1;
  2050.     u->headers_in.last_modified_time = -1;

  2052.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2053.                       sizeof(ngx_table_elt_t))
  2054.         != NGX_OK)
  2055.     {
  2056.         return NGX_ERROR;
  2057.     }

  2059.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2060.                       sizeof(ngx_table_elt_t))
  2061.         != NGX_OK)
  2062.     {
  2063.         return NGX_ERROR;
  2064.     }

  2066.     /* reinit the request chain */

  2068.     file_pos = 0;

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

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

  2075.         if (cl->buf->in_file) {
  2076.             cl->buf->file_pos = file_pos;
  2077.             file_pos = cl->buf->file_last;
  2078.         }
  2079.     }

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

  2083.     if (r->request_body && r->request_body->temp_file
  2084.         && r != r->main && u->output.buf)
  2085.     {
  2086.         u->output.free = ngx_alloc_chain_link(r->pool);
  2087.         if (u->output.free == NULL) {
  2088.             return NGX_ERROR;
  2089.         }

  2091.         u->output.free->buf = u->output.buf;
  2092.         u->output.free->next = NULL;

  2094.         u->output.buf->pos = u->output.buf->start;
  2095.         u->output.buf->last = u->output.buf->start;
  2096.     }

  2098.     u->output.buf = NULL;
  2099.     u->output.in = NULL;
  2100.     u->output.busy = NULL;

  2102.     /* reinit u->buffer */

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

  2106. #if (NGX_HTTP_CACHE)

  2108.     if (r->cache) {
  2109.         u->buffer.pos += r->cache->header_start;
  2110.     }

  2112. #endif

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

  2116.     return NGX_OK;
  2117. }


  2120. static void
  2121. ‌ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u,
  2122.     ngx_uint_t do_write)
  2123. {
  2124.     ngx_int_t          rc;
  2125.     ngx_connection_t  *c;

  2127.     c = u->peer.connection;

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

  2132.     if (u->state->connect_time == (ngx_msec_t) -1) {
  2133.         u->state->connect_time = ngx_current_msec - u->start_time;
  2134.     }

  2136.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2137.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2138.         return;
  2139.     }

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

  2143.     rc = ngx_http_upstream_send_request_body(r, u, do_write);

  2145.     if (rc == NGX_ERROR) {
  2146.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2147.         return;
  2148.     }

  2150.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2151.         ngx_http_upstream_finalize_request(r, u, rc);
  2152.         return;
  2153.     }

  2155.     if (rc == NGX_AGAIN) {
  2156.         if (!c->write->ready || u->request_body_blocked) {
  2157.             ngx_add_timer(c->write, u->conf->send_timeout);

  2159.         } else if (c->write->timer_set) {
  2160.             ngx_del_timer(c->write);
  2161.         }

  2163.         if (ngx_handle_write_event(c->write, u->conf->send_lowat) != NGX_OK) {
  2164.             ngx_http_upstream_finalize_request(r, u,
  2165.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2166.             return;
  2167.         }

  2169.         if (c->write->ready && c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2170.             if (ngx_tcp_push(c->fd) == -1) {
  2171.                 ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2172.                               ngx_tcp_push_n " failed");
  2173.                 ngx_http_upstream_finalize_request(r, u,
  2174.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2175.                 return;
  2176.             }

  2178.             c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2179.         }

  2181.         if (c->read->ready) {
  2182.             ngx_post_event(c->read, &ngx_posted_events);
  2183.         }

  2185.         return;
  2186.     }

  2188.     /* rc == NGX_OK */

  2190.     if (c->write->timer_set) {
  2191.         ngx_del_timer(c->write);
  2192.     }

  2194.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2195.         if (ngx_tcp_push(c->fd) == -1) {
  2196.             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2197.                           ngx_tcp_push_n " failed");
  2198.             ngx_http_upstream_finalize_request(r, u,
  2199.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2200.             return;
  2201.         }

  2203.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2204.     }

  2206.     if (!u->conf->preserve_output) {
  2207.         u->write_event_handler = ngx_http_upstream_dummy_handler;
  2208.     }

  2210.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2211.         ngx_http_upstream_finalize_request(r, u,
  2212.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2213.         return;
  2214.     }

  2216.     if (!u->request_body_sent) {
  2217.         u->request_body_sent = 1;

  2219.         if (u->header_sent) {
  2220.             return;
  2221.         }

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

  2225.         if (c->read->ready) {
  2226.             ngx_http_upstream_process_header(r, u);
  2227.             return;
  2228.         }
  2229.     }
  2230. }


  2233. static ngx_int_t
  2234. ‌ngx_http_upstream_send_request_body(ngx_http_request_t *r,
  2235.     ngx_http_upstream_t *u, ngx_uint_t do_write)
  2236. {
  2237.     ngx_int_t                  rc;
  2238.     ngx_chain_t               *out, *cl, *ln;
  2239.     ngx_connection_t          *c;
  2240.     ngx_http_core_loc_conf_t  *clcf;

  2242.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2243.                    "http upstream send request body");

  2245.     if (!r->request_body_no_buffering) {

  2247.         /* buffered request body */

  2249.         if (!u->request_sent) {
  2250.             u->request_sent = 1;
  2251.             out = u->request_bufs;

  2253.         } else {
  2254.             out = NULL;
  2255.         }

  2257.         rc = ngx_output_chain(&u->output, out);

  2259.         if (rc == NGX_AGAIN) {
  2260.             u->request_body_blocked = 1;

  2262.         } else {
  2263.             u->request_body_blocked = 0;
  2264.         }

  2266.         return rc;
  2267.     }

  2269.     if (!u->request_sent) {
  2270.         u->request_sent = 1;
  2271.         out = u->request_bufs;

  2273.         if (r->request_body->bufs) {
  2274.             for (cl = out; cl->next; cl = cl->next) { /* void */ }
  2275.             cl->next = r->request_body->bufs;
  2276.             r->request_body->bufs = NULL;
  2277.         }

  2279.         c = u->peer.connection;
  2280.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2282.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  2283.             return NGX_ERROR;
  2284.         }

  2286.         r->read_event_handler = ngx_http_upstream_read_request_handler;

  2288.     } else {
  2289.         out = NULL;
  2290.     }

  2292.     for ( ;; ) {

  2294.         if (do_write) {
  2295.             rc = ngx_output_chain(&u->output, out);

  2297.             if (rc == NGX_ERROR) {
  2298.                 return NGX_ERROR;
  2299.             }

  2301.             while (out) {
  2302.                 ln = out;
  2303.                 out = out->next;
  2304.                 ngx_free_chain(r->pool, ln);
  2305.             }

  2307.             if (rc == NGX_AGAIN) {
  2308.                 u->request_body_blocked = 1;

  2310.             } else {
  2311.                 u->request_body_blocked = 0;
  2312.             }

  2314.             if (rc == NGX_OK && !r->reading_body) {
  2315.                 break;
  2316.             }
  2317.         }

  2319.         if (r->reading_body) {
  2320.             /* read client request body */

  2322.             rc = ngx_http_read_unbuffered_request_body(r);

  2324.             if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2325.                 return rc;
  2326.             }

  2328.             out = r->request_body->bufs;
  2329.             r->request_body->bufs = NULL;
  2330.         }

  2332.         /* stop if there is nothing to send */

  2334.         if (out == NULL) {
  2335.             rc = NGX_AGAIN;
  2336.             break;
  2337.         }

  2339.         do_write = 1;
  2340.     }

  2342.     if (!r->reading_body) {
  2343.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2344.             r->read_event_handler =
  2345.                                   ngx_http_upstream_rd_check_broken_connection;
  2346.         }
  2347.     }

  2349.     return rc;
  2350. }


  2353. static void
  2354. ‌ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  2355.     ngx_http_upstream_t *u)
  2356. {
  2357.     ngx_connection_t  *c;

  2359.     c = u->peer.connection;

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

  2364.     if (c->write->timedout) {
  2365.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2366.         return;
  2367.     }

  2369. #if (NGX_HTTP_SSL)

  2371.     if (u->ssl && c->ssl == NULL) {
  2372.         ngx_http_upstream_ssl_init_connection(r, u, c);
  2373.         return;
  2374.     }

  2376. #endif

  2378.     if (u->header_sent && !u->conf->preserve_output) {
  2379.         u->write_event_handler = ngx_http_upstream_dummy_handler;

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

  2383.         return;
  2384.     }

  2386.     ngx_http_upstream_send_request(r, u, 1);
  2387. }


  2390. static void
  2391. ‌ngx_http_upstream_read_request_handler(ngx_http_request_t *r)
  2392. {
  2393.     ngx_connection_t     *c;
  2394.     ngx_http_upstream_t  *u;

  2396.     c = r->connection;
  2397.     u = r->upstream;

  2399.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2400.                    "http upstream read request handler");

  2402.     if (c->read->timedout) {
  2403.         c->timedout = 1;
  2404.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  2405.         return;
  2406.     }

  2408.     ngx_http_upstream_send_request(r, u, 0);
  2409. }


  2412. static void
  2413. ‌ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2414. {
  2415.     ssize_t            n;
  2416.     ngx_int_t          rc;
  2417.     ngx_connection_t  *c;

  2419.     c = u->peer.connection;

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

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

  2426.     if (c->read->timedout) {
  2427.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2428.         return;
  2429.     }

  2431.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2432.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2433.         return;
  2434.     }

  2436.     if (u->buffer.start == NULL) {
  2437.         u->buffer.start = ngx_palloc(r->pool, u->conf->buffer_size);
  2438.         if (u->buffer.start == NULL) {
  2439.             ngx_http_upstream_finalize_request(r, u,
  2440.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2441.             return;
  2442.         }

  2444.         u->buffer.pos = u->buffer.start;
  2445.         u->buffer.last = u->buffer.start;
  2446.         u->buffer.end = u->buffer.start + u->conf->buffer_size;
  2447.         u->buffer.temporary = 1;

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

  2451.         if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2452.                           sizeof(ngx_table_elt_t))
  2453.             != NGX_OK)
  2454.         {
  2455.             ngx_http_upstream_finalize_request(r, u,
  2456.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2457.             return;
  2458.         }

  2460.         if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2461.                           sizeof(ngx_table_elt_t))
  2462.             != NGX_OK)
  2463.         {
  2464.             ngx_http_upstream_finalize_request(r, u,
  2465.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2466.             return;
  2467.         }

  2469. #if (NGX_HTTP_CACHE)

  2471.         if (r->cache) {
  2472.             u->buffer.pos += r->cache->header_start;
  2473.             u->buffer.last = u->buffer.pos;
  2474.         }
  2475. #endif
  2476.     }

  2478.     for ( ;; ) {

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

  2482.         if (n == NGX_AGAIN) {
  2483. #if 0
  2484.             ngx_add_timer(rev, u->read_timeout);
  2485. #endif

  2487.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2488.                 ngx_http_upstream_finalize_request(r, u,
  2489.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2490.                 return;
  2491.             }

  2493.             return;
  2494.         }

  2496.         if (n == 0) {
  2497.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2498.                           "upstream prematurely closed connection");
  2499.         }

  2501.         if (n == NGX_ERROR || n == 0) {
  2502.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2503.             return;
  2504.         }

  2506.         u->state->bytes_received += n;

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

  2510. #if 0
  2511.         u->valid_header_in = 0;

  2513.         u->peer.cached = 0;
  2514. #endif

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

  2518.         if (rc == NGX_AGAIN) {

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

  2524.                 ngx_http_upstream_next(r, u,
  2525.                                        NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2526.                 return;
  2527.             }

  2529.             continue;
  2530.         }

  2532.         break;
  2533.     }

  2535.     if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2536.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2537.         return;
  2538.     }

  2540.     if (rc == NGX_ERROR) {
  2541.         ngx_http_upstream_finalize_request(r, u,
  2542.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2543.         return;
  2544.     }

  2546.     /* rc == NGX_OK */

  2548.     u->state->header_time = ngx_current_msec - u->start_time;

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

  2552.         if (ngx_http_upstream_test_next(r, u) == NGX_OK) {
  2553.             return;
  2554.         }

  2556.         if (ngx_http_upstream_intercept_errors(r, u) == NGX_OK) {
  2557.             return;
  2558.         }
  2559.     }

  2561.     if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  2562.         return;
  2563.     }

  2565.     ngx_http_upstream_send_response(r, u);
  2566. }


  2569. static ngx_int_t
  2570. ‌ngx_http_upstream_test_next(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2571. {
  2572.     ngx_msec_t                 timeout;
  2573.     ngx_uint_t                 status, mask;
  2574.     ngx_http_upstream_next_t  *un;

  2576.     status = u->headers_in.status_n;

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

  2580.         if (status != un->status) {
  2581.             continue;
  2582.         }

  2584.         timeout = u->conf->next_upstream_timeout;

  2586.         if (u->request_sent
  2587.             && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  2588.         {
  2589.             mask = un->mask | NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;

  2591.         } else {
  2592.             mask = un->mask;
  2593.         }

  2595.         if (u->peer.tries > 1
  2596.             && ((u->conf->next_upstream & mask) == mask)
  2597.             && !(u->request_sent && r->request_body_no_buffering)
  2598.             && !(timeout && ngx_current_msec - u->peer.start_time >= timeout))
  2599.         {
  2600.             ngx_http_upstream_next(r, u, un->mask);
  2601.             return NGX_OK;
  2602.         }

  2604. #if (NGX_HTTP_CACHE)

  2606.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2607.             && (u->conf->cache_use_stale & un->mask))
  2608.         {
  2609.             ngx_int_t  rc;

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

  2613.             if (rc != NGX_OK) {
  2614.                 ngx_http_upstream_finalize_request(r, u, rc);
  2615.                 return NGX_OK;
  2616.             }

  2618.             u->cache_status = NGX_HTTP_CACHE_STALE;
  2619.             rc = ngx_http_upstream_cache_send(r, u);

  2621.             if (rc == NGX_DONE) {
  2622.                 return NGX_OK;
  2623.             }

  2625.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2626.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2627.             }

  2629.             ngx_http_upstream_finalize_request(r, u, rc);
  2630.             return NGX_OK;
  2631.         }

  2633. #endif

  2635.         break;
  2636.     }

  2638. #if (NGX_HTTP_CACHE)

  2640.     if (status == NGX_HTTP_NOT_MODIFIED
  2641.         && u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2642.         && u->conf->cache_revalidate)
  2643.     {
  2644.         time_t     now, valid, updating, error;
  2645.         ngx_int_t  rc;

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

  2650.         now = ngx_time();

  2652.         valid = r->cache->valid_sec;
  2653.         updating = r->cache->updating_sec;
  2654.         error = r->cache->error_sec;

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

  2658.         if (rc != NGX_OK) {
  2659.             ngx_http_upstream_finalize_request(r, u, rc);
  2660.             return NGX_OK;
  2661.         }

  2663.         u->cache_status = NGX_HTTP_CACHE_REVALIDATED;
  2664.         rc = ngx_http_upstream_cache_send(r, u);

  2666.         if (rc == NGX_DONE) {
  2667.             return NGX_OK;
  2668.         }

  2670.         if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2671.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2672.         }

  2674.         if (valid == 0) {
  2675.             valid = r->cache->valid_sec;
  2676.             updating = r->cache->updating_sec;
  2677.             error = r->cache->error_sec;
  2678.         }

  2680.         if (valid == 0) {
  2681.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2682.                                               u->headers_in.status_n);
  2683.             if (valid) {
  2684.                 valid = now + valid;
  2685.             }
  2686.         }

  2688.         if (valid) {
  2689.             r->cache->valid_sec = valid;
  2690.             r->cache->updating_sec = updating;
  2691.             r->cache->error_sec = error;

  2693.             r->cache->date = now;

  2695.             ngx_http_file_cache_update_header(r);
  2696.         }

  2698.         ngx_http_upstream_finalize_request(r, u, rc);
  2699.         return NGX_OK;
  2700.     }

  2702. #endif

  2704.     return NGX_DECLINED;
  2705. }


  2708. static ngx_int_t
  2709. ‌ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  2710.     ngx_http_upstream_t *u)
  2711. {
  2712.     ngx_int_t                  status;
  2713.     ngx_uint_t                 i;
  2714.     ngx_table_elt_t           *h, *ho, **ph;
  2715.     ngx_http_err_page_t       *err_page;
  2716.     ngx_http_core_loc_conf_t  *clcf;

  2718.     status = u->headers_in.status_n;

  2720.     if (status == NGX_HTTP_NOT_FOUND && u->conf->intercept_404) {
  2721.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_NOT_FOUND);
  2722.         return NGX_OK;
  2723.     }

  2725.     if (!u->conf->intercept_errors) {
  2726.         return NGX_DECLINED;
  2727.     }

  2729.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2731.     if (clcf->error_pages == NULL) {
  2732.         return NGX_DECLINED;
  2733.     }

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

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

  2740.             if (status == NGX_HTTP_UNAUTHORIZED
  2741.                 && u->headers_in.www_authenticate)
  2742.             {
  2743.                 h = u->headers_in.www_authenticate;
  2744.                 ph = &r->headers_out.www_authenticate;

  2746.                 while (h) {
  2747.                     ho = ngx_list_push(&r->headers_out.headers);

  2749.                     if (ho == NULL) {
  2750.                         ngx_http_upstream_finalize_request(r, u,
  2751.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2752.                         return NGX_OK;
  2753.                     }

  2755.                     *ho = *h;
  2756.                     ho->next = NULL;

  2758.                     *ph = ho;
  2759.                     ph = &ho->next;

  2761.                     h = h->next;
  2762.                 }
  2763.             }

  2765. #if (NGX_HTTP_CACHE)

  2767.             if (r->cache) {

  2769.                 if (u->headers_in.no_cache || u->headers_in.expired) {
  2770.                     u->cacheable = 0;
  2771.                 }

  2773.                 if (u->cacheable) {
  2774.                     time_t  valid;

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

  2778.                     if (valid == 0) {
  2779.                         valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2780.                                                           status);
  2781.                         if (valid) {
  2782.                             r->cache->valid_sec = ngx_time() + valid;
  2783.                         }
  2784.                     }

  2786.                     if (valid) {
  2787.                         r->cache->error = status;
  2788.                     }
  2789.                 }

  2791.                 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  2792.             }
  2793. #endif
  2794.             ngx_http_upstream_finalize_request(r, u, status);

  2796.             return NGX_OK;
  2797.         }
  2798.     }

  2800.     return NGX_DECLINED;
  2801. }


  2804. static ngx_int_t
  2805. ‌ngx_http_upstream_test_connect(ngx_connection_t *c)
  2806. {
  2807.     int        err;
  2808.     socklen_t  len;

  2810. #if (NGX_HAVE_KQUEUE)

  2812.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
  2813.         if (c->write->pending_eof || c->read->pending_eof) {
  2814.             if (c->write->pending_eof) {
  2815.                 err = c->write->kq_errno;

  2817.             } else {
  2818.                 err = c->read->kq_errno;
  2819.             }

  2821.             c->log->action = "connecting to upstream";
  2822.             (void) ngx_connection_error(c, err,
  2823.                                     "kevent() reported that connect() failed");
  2824.             return NGX_ERROR;
  2825.         }

  2827.     } else
  2828. #endif
  2829.     {
  2830.         err = 0;
  2831.         len = sizeof(int);

  2833.         /*
  2834.          * BSDs and Linux return 0 and set a pending error in err
  2835.          * Solaris returns -1 and sets errno
  2836.          */

  2838.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  2839.             == -1)
  2840.         {
  2841.             err = ngx_socket_errno;
  2842.         }

  2844.         if (err) {
  2845.             c->log->action = "connecting to upstream";
  2846.             (void) ngx_connection_error(c, err, "connect() failed");
  2847.             return NGX_ERROR;
  2848.         }
  2849.     }

  2851.     return NGX_OK;
  2852. }


  2855. static ngx_int_t
  2856. ‌ngx_http_upstream_process_headers(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2857. {
  2858.     ngx_str_t                       uri, args;
  2859.     ngx_uint_t                      i, flags;
  2860.     ngx_list_part_t                *part;
  2861.     ngx_table_elt_t                *h;
  2862.     ngx_http_upstream_header_t     *hh;
  2863.     ngx_http_upstream_main_conf_t  *umcf;

  2865.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  2867.     if (u->headers_in.no_cache || u->headers_in.expired) {
  2868.         u->cacheable = 0;
  2869.     }

  2871.     if (u->headers_in.x_accel_redirect
  2872.         && !(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT))
  2873.     {
  2874.         ngx_http_upstream_finalize_request(r, u, NGX_DECLINED);

  2876.         part = &u->headers_in.headers.part;
  2877.         h = part->elts;

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

  2881.             if (i >= part->nelts) {
  2882.                 if (part->next == NULL) {
  2883.                     break;
  2884.                 }

  2886.                 part = part->next;
  2887.                 h = part->elts;
  2888.                 i = 0;
  2889.             }

  2891.             if (h[i].hash == 0) {
  2892.                 continue;
  2893.             }

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

  2898.             if (hh && hh->redirect) {
  2899.                 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  2900.                     ngx_http_finalize_request(r,
  2901.                                               NGX_HTTP_INTERNAL_SERVER_ERROR);
  2902.                     return NGX_DONE;
  2903.                 }
  2904.             }
  2905.         }

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

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

  2912.         } else {
  2913.             ngx_str_null(&args);
  2914.             flags = NGX_HTTP_LOG_UNSAFE;

  2916.             if (ngx_http_parse_unsafe_uri(r, &uri, &args, &flags) != NGX_OK) {
  2917.                 ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  2918.                 return NGX_DONE;
  2919.             }

  2921.             if (r->method != NGX_HTTP_HEAD) {
  2922.                 r->method = NGX_HTTP_GET;
  2923.                 r->method_name = ngx_http_core_get_method;
  2924.             }

  2926.             ngx_http_internal_redirect(r, &uri, &args);
  2927.         }

  2929.         ngx_http_finalize_request(r, NGX_DONE);
  2930.         return NGX_DONE;
  2931.     }

  2933.     part = &u->headers_in.headers.part;
  2934.     h = part->elts;

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

  2938.         if (i >= part->nelts) {
  2939.             if (part->next == NULL) {
  2940.                 break;
  2941.             }

  2943.             part = part->next;
  2944.             h = part->elts;
  2945.             i = 0;
  2946.         }

  2948.         if (h[i].hash == 0) {
  2949.             continue;
  2950.         }

  2952.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  2953.                           h[i].lowcase_key, h[i].key.len))
  2954.         {
  2955.             continue;
  2956.         }

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

  2961.         if (hh) {
  2962.             if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  2963.                 ngx_http_upstream_finalize_request(r, u,
  2964.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2965.                 return NGX_DONE;
  2966.             }

  2968.             continue;
  2969.         }

  2971.         if (ngx_http_upstream_copy_header_line(r, &h[i], 0) != NGX_OK) {
  2972.             ngx_http_upstream_finalize_request(r, u,
  2973.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2974.             return NGX_DONE;
  2975.         }
  2976.     }

  2978.     if (r->headers_out.server && r->headers_out.server->value.data == NULL) {
  2979.         r->headers_out.server->hash = 0;
  2980.     }

  2982.     if (r->headers_out.date && r->headers_out.date->value.data == NULL) {
  2983.         r->headers_out.date->hash = 0;
  2984.     }

  2986.     r->headers_out.status = u->headers_in.status_n;
  2987.     r->headers_out.status_line = u->headers_in.status_line;

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

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

  2993.     if (u->conf->force_ranges) {
  2994.         r->allow_ranges = 1;
  2995.         r->single_range = 1;

  2997. #if (NGX_HTTP_CACHE)
  2998.         if (r->cached) {
  2999.             r->single_range = 0;
  3000.         }
  3001. #endif
  3002.     }

  3004.     u->length = -1;

  3006.     return NGX_OK;
  3007. }


  3010. static ngx_int_t
  3011. ‌ngx_http_upstream_process_trailers(ngx_http_request_t *r,
  3012.     ngx_http_upstream_t *u)
  3013. {
  3014.     ngx_uint_t        i;
  3015.     ngx_list_part_t  *part;
  3016.     ngx_table_elt_t  *h, *ho;

  3018.     if (!u->conf->pass_trailers) {
  3019.         return NGX_OK;
  3020.     }

  3022.     part = &u->headers_in.trailers.part;
  3023.     h = part->elts;

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

  3027.         if (i >= part->nelts) {
  3028.             if (part->next == NULL) {
  3029.                 break;
  3030.             }

  3032.             part = part->next;
  3033.             h = part->elts;
  3034.             i = 0;
  3035.         }

  3037.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3038.                           h[i].lowcase_key, h[i].key.len))
  3039.         {
  3040.             continue;
  3041.         }

  3043.         ho = ngx_list_push(&r->headers_out.trailers);
  3044.         if (ho == NULL) {
  3045.             return NGX_ERROR;
  3046.         }

  3048.         *ho = h[i];
  3049.     }

  3051.     return NGX_OK;
  3052. }


  3055. static void
  3056. ‌ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3057. {
  3058.     ssize_t                    n;
  3059.     ngx_int_t                  rc;
  3060.     ngx_event_pipe_t          *p;
  3061.     ngx_connection_t          *c;
  3062.     ngx_http_core_loc_conf_t  *clcf;

  3064.     rc = ngx_http_send_header(r);

  3066.     if (rc == NGX_ERROR || rc > NGX_OK || r->post_action) {
  3067.         ngx_http_upstream_finalize_request(r, u, rc);
  3068.         return;
  3069.     }

  3071.     u->header_sent = 1;

  3073.     if (u->upgrade) {

  3075. #if (NGX_HTTP_CACHE)

  3077.         if (r->cache) {
  3078.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3079.         }

  3081. #endif

  3083.         ngx_http_upstream_upgrade(r, u);
  3084.         return;
  3085.     }

  3087.     c = r->connection;

  3089.     if (r->header_only) {

  3091.         if (!u->buffering) {
  3092.             ngx_http_upstream_finalize_request(r, u, rc);
  3093.             return;
  3094.         }

  3096.         if (!u->cacheable && !u->store) {
  3097.             ngx_http_upstream_finalize_request(r, u, rc);
  3098.             return;
  3099.         }

  3101.         u->pipe->downstream_error = 1;
  3102.     }

  3104.     if (r->request_body && r->request_body->temp_file
  3105.         && r == r->main && !r->preserve_body
  3106.         && !u->conf->preserve_output)
  3107.     {
  3108.         ngx_pool_run_cleanup_file(r->pool, r->request_body->temp_file->file.fd);
  3109.         r->request_body->temp_file->file.fd = NGX_INVALID_FILE;
  3110.     }

  3112.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3114.     if (!u->buffering) {

  3116. #if (NGX_HTTP_CACHE)

  3118.         if (r->cache) {
  3119.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3120.         }

  3122. #endif

  3124.         if (u->input_filter == NULL) {
  3125.             u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
  3126.             u->input_filter = ngx_http_upstream_non_buffered_filter;
  3127.             u->input_filter_ctx = r;
  3128.         }

  3130.         u->read_event_handler = ngx_http_upstream_process_non_buffered_upstream;
  3131.         r->write_event_handler =
  3132.                              ngx_http_upstream_process_non_buffered_downstream;

  3134.         r->limit_rate = 0;
  3135.         r->limit_rate_set = 1;

  3137.         if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
  3138.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3139.             return;
  3140.         }

  3142.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3143.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3144.             return;
  3145.         }

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

  3149.         if (n) {
  3150.             u->buffer.last = u->buffer.pos;

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

  3154.             if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  3155.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3156.                 return;
  3157.             }

  3159.             ngx_http_upstream_process_non_buffered_downstream(r);

  3161.         } else {
  3162.             u->buffer.pos = u->buffer.start;
  3163.             u->buffer.last = u->buffer.start;

  3165.             if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3166.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3167.                 return;
  3168.             }

  3170.             ngx_http_upstream_process_non_buffered_upstream(r, u);
  3171.         }

  3173.         return;
  3174.     }

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

  3178. #if (NGX_HTTP_CACHE)

  3180.     if (r->cache && r->cache->file.fd != NGX_INVALID_FILE) {
  3181.         ngx_pool_run_cleanup_file(r->pool, r->cache->file.fd);
  3182.         r->cache->file.fd = NGX_INVALID_FILE;
  3183.     }

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

  3187.     case NGX_ERROR:
  3188.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3189.         return;

  3191.     case NGX_DECLINED:
  3192.         u->cacheable = 0;
  3193.         break;

  3195.     default: /* NGX_OK */

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

  3199.             /* create cache if previously bypassed */

  3201.             if (ngx_http_file_cache_create(r) != NGX_OK) {
  3202.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3203.                 return;
  3204.             }
  3205.         }

  3207.         break;
  3208.     }

  3210.     if (u->cacheable) {
  3211.         time_t  now, valid;

  3213.         now = ngx_time();

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

  3217.         if (valid == 0) {
  3218.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  3219.                                               u->headers_in.status_n);
  3220.             if (valid) {
  3221.                 r->cache->valid_sec = now + valid;
  3222.             }
  3223.         }

  3225.         if (valid) {
  3226.             r->cache->date = now;
  3227.             r->cache->body_start = (u_short) (u->buffer.pos - u->buffer.start);

  3229.             if (u->headers_in.status_n == NGX_HTTP_OK
  3230.                 || u->headers_in.status_n == NGX_HTTP_PARTIAL_CONTENT)
  3231.             {
  3232.                 r->cache->last_modified = u->headers_in.last_modified_time;

  3234.                 if (u->headers_in.etag) {
  3235.                     r->cache->etag = u->headers_in.etag->value;

  3237.                 } else {
  3238.                     ngx_str_null(&r->cache->etag);
  3239.                 }

  3241.             } else {
  3242.                 r->cache->last_modified = -1;
  3243.                 ngx_str_null(&r->cache->etag);
  3244.             }

  3246.             if (ngx_http_file_cache_set_header(r, u->buffer.start) != NGX_OK) {
  3247.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3248.                 return;
  3249.             }

  3251.         } else {
  3252.             u->cacheable = 0;
  3253.         }
  3254.     }

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

  3259.     if (u->cacheable == 0 && r->cache) {
  3260.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3261.     }

  3263.     if (r->header_only && !u->cacheable && !u->store) {
  3264.         ngx_http_upstream_finalize_request(r, u, 0);
  3265.         return;
  3266.     }

  3268. #endif

  3270.     p = u->pipe;

  3272.     p->output_filter = ngx_http_upstream_output_filter;
  3273.     p->output_ctx = r;
  3274.     p->tag = u->output.tag;
  3275.     p->bufs = u->conf->bufs;
  3276.     p->busy_size = u->conf->busy_buffers_size;
  3277.     p->upstream = u->peer.connection;
  3278.     p->downstream = c;
  3279.     p->pool = r->pool;
  3280.     p->log = c->log;
  3281.     p->limit_rate = ngx_http_complex_value_size(r, u->conf->limit_rate, 0);
  3282.     p->start_sec = ngx_time();

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

  3286.     p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  3287.     if (p->temp_file == NULL) {
  3288.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3289.         return;
  3290.     }

  3292.     p->temp_file->file.fd = NGX_INVALID_FILE;
  3293.     p->temp_file->file.log = c->log;
  3294.     p->temp_file->path = u->conf->temp_path;
  3295.     p->temp_file->pool = r->pool;

  3297.     if (p->cacheable) {
  3298.         p->temp_file->persistent = 1;

  3300. #if (NGX_HTTP_CACHE)
  3301.         if (r->cache && !r->cache->file_cache->use_temp_path) {
  3302.             p->temp_file->path = r->cache->file_cache->path;
  3303.             p->temp_file->file.name = r->cache->file.name;
  3304.         }
  3305. #endif

  3307.     } else {
  3308.         p->temp_file->log_level = NGX_LOG_WARN;
  3309.         p->temp_file->warn = "an upstream response is buffered "
  3310.                              "to a temporary file";
  3311.     }

  3313.     p->max_temp_file_size = u->conf->max_temp_file_size;
  3314.     p->temp_file_write_size = u->conf->temp_file_write_size;

  3316. #if (NGX_THREADS)
  3317.     if (clcf->aio == NGX_HTTP_AIO_THREADS && clcf->aio_write) {
  3318.         p->thread_handler = ngx_http_upstream_thread_handler;
  3319.         p->thread_ctx = r;
  3320.     }
  3321. #endif

  3323.     p->preread_bufs = ngx_alloc_chain_link(r->pool);
  3324.     if (p->preread_bufs == NULL) {
  3325.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3326.         return;
  3327.     }

  3329.     p->preread_bufs->buf = &u->buffer;
  3330.     p->preread_bufs->next = NULL;
  3331.     u->buffer.recycled = 1;

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

  3335.     if (u->cacheable) {

  3337.         p->buf_to_file = ngx_calloc_buf(r->pool);
  3338.         if (p->buf_to_file == NULL) {
  3339.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3340.             return;
  3341.         }

  3343.         p->buf_to_file->start = u->buffer.start;
  3344.         p->buf_to_file->pos = u->buffer.start;
  3345.         p->buf_to_file->last = u->buffer.pos;
  3346.         p->buf_to_file->temporary = 1;
  3347.     }

  3349.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  3350.         /* the posted aio operation may corrupt a shadow buffer */
  3351.         p->single_buf = 1;
  3352.     }

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

  3357.     /*
  3358.      * event_pipe would do u->buffer.last += p->preread_size
  3359.      * as though these bytes were read
  3360.      */
  3361.     u->buffer.last = u->buffer.pos;

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

  3365.         /*
  3366.          * we need to disable the use of sendfile() if we use cyclic temp file
  3367.          * because the writing a new data may interfere with sendfile()
  3368.          * that uses the same kernel file pages (at least on FreeBSD)
  3369.          */

  3371.         p->cyclic_temp_file = 1;
  3372.         c->sendfile = 0;

  3374.     } else {
  3375.         p->cyclic_temp_file = 0;
  3376.     }

  3378.     p->read_timeout = u->conf->read_timeout;
  3379.     p->send_timeout = clcf->send_timeout;
  3380.     p->send_lowat = clcf->send_lowat;

  3382.     p->length = -1;

  3384.     if (u->input_filter_init
  3385.         && u->input_filter_init(p->input_ctx) != NGX_OK)
  3386.     {
  3387.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3388.         return;
  3389.     }

  3391.     u->read_event_handler = ngx_http_upstream_process_upstream;
  3392.     r->write_event_handler = ngx_http_upstream_process_downstream;

  3394.     ngx_http_upstream_process_upstream(r, u);
  3395. }


  3398. static void
  3399. ‌ngx_http_upstream_upgrade(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3400. {
  3401.     ngx_connection_t          *c;
  3402.     ngx_http_core_loc_conf_t  *clcf;

  3404.     c = r->connection;
  3405.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  3409.     if (r != r->main) {
  3410.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  3411.                       "connection upgrade in subrequest");
  3412.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3413.         return;
  3414.     }

  3416.     r->keepalive = 0;
  3417.     c->log->action = "proxying upgraded connection";

  3419.     u->read_event_handler = ngx_http_upstream_upgraded_read_upstream;
  3420.     u->write_event_handler = ngx_http_upstream_upgraded_write_upstream;
  3421.     r->read_event_handler = ngx_http_upstream_upgraded_read_downstream;
  3422.     r->write_event_handler = ngx_http_upstream_upgraded_write_downstream;

  3424.     if (clcf->tcp_nodelay) {

  3426.         if (ngx_tcp_nodelay(c) != NGX_OK) {
  3427.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3428.             return;
  3429.         }

  3431.         if (ngx_tcp_nodelay(u->peer.connection) != NGX_OK) {
  3432.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3433.             return;
  3434.         }
  3435.     }

  3437.     if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3438.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3439.         return;
  3440.     }

  3442.     if (u->peer.connection->read->ready
  3443.         || u->buffer.pos != u->buffer.last)
  3444.     {
  3445.         ngx_post_event(c->read, &ngx_posted_events);
  3446.         ngx_http_upstream_process_upgraded(r, 1, 1);
  3447.         return;
  3448.     }

  3450.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3451. }


  3454. static void
  3455. ‌ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r)
  3456. {
  3457.     ngx_http_upstream_process_upgraded(r, 0, 0);
  3458. }


  3461. static void
  3462. ‌ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r)
  3463. {
  3464.     ngx_http_upstream_process_upgraded(r, 1, 1);
  3465. }


  3468. static void
  3469. ‌ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  3470.     ngx_http_upstream_t *u)
  3471. {
  3472.     ngx_http_upstream_process_upgraded(r, 1, 0);
  3473. }


  3476. static void
  3477. ‌ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  3478.     ngx_http_upstream_t *u)
  3479. {
  3480.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3481. }


  3484. static void
  3485. ‌ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  3486.     ngx_uint_t from_upstream, ngx_uint_t do_write)
  3487. {
  3488.     size_t                     size;
  3489.     ssize_t                    n;
  3490.     ngx_buf_t                 *b;
  3491.     ngx_uint_t                 flags;
  3492.     ngx_connection_t          *c, *downstream, *upstream, *dst, *src;
  3493.     ngx_http_upstream_t       *u;
  3494.     ngx_http_core_loc_conf_t  *clcf;

  3496.     c = r->connection;
  3497.     u = r->upstream;

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

  3502.     downstream = c;
  3503.     upstream = u->peer.connection;

  3505.     if (downstream->write->timedout) {
  3506.         c->timedout = 1;
  3507.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3508.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3509.         return;
  3510.     }

  3512.     if (upstream->read->timedout || upstream->write->timedout) {
  3513.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3514.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3515.         return;
  3516.     }

  3518.     if (from_upstream) {
  3519.         src = upstream;
  3520.         dst = downstream;
  3521.         b = &u->buffer;

  3523.     } else {
  3524.         src = downstream;
  3525.         dst = upstream;
  3526.         b = &u->from_client;

  3528.         if (r->header_in->last > r->header_in->pos) {
  3529.             b = r->header_in;
  3530.             b->end = b->last;
  3531.             do_write = 1;
  3532.         }

  3534.         if (b->start == NULL) {
  3535.             b->start = ngx_palloc(r->pool, u->conf->buffer_size);
  3536.             if (b->start == NULL) {
  3537.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3538.                 return;
  3539.             }

  3541.             b->pos = b->start;
  3542.             b->last = b->start;
  3543.             b->end = b->start + u->conf->buffer_size;
  3544.             b->temporary = 1;
  3545.             b->tag = u->output.tag;
  3546.         }
  3547.     }

  3549.     for ( ;; ) {

  3551.         if (do_write) {

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

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

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

  3559.                 if (n == NGX_ERROR) {
  3560.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3561.                     return;
  3562.                 }

  3564.                 if (n > 0) {
  3565.                     b->pos += n;

  3567.                     if (b->pos == b->last) {
  3568.                         b->pos = b->start;
  3569.                         b->last = b->start;
  3570.                     }
  3571.                 }
  3572.             }
  3573.         }

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

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

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

  3581.             if (n == NGX_AGAIN || n == 0) {
  3582.                 break;
  3583.             }

  3585.             if (n > 0) {
  3586.                 do_write = 1;
  3587.                 b->last += n;

  3589.                 if (from_upstream) {
  3590.                     u->state->bytes_received += n;
  3591.                 }

  3593.                 continue;
  3594.             }

  3596.             if (n == NGX_ERROR) {
  3597.                 src->read->eof = 1;
  3598.             }
  3599.         }

  3601.         break;
  3602.     }

  3604.     if ((upstream->read->eof && u->buffer.pos == u->buffer.last)
  3605.         || (downstream->read->eof && u->from_client.pos == u->from_client.last)
  3606.         || (downstream->read->eof && upstream->read->eof))
  3607.     {
  3608.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3609.                        "http upstream upgraded done");
  3610.         ngx_http_upstream_finalize_request(r, u, 0);
  3611.         return;
  3612.     }

  3614.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3616.     if (ngx_handle_write_event(upstream->write, u->conf->send_lowat)
  3617.         != NGX_OK)
  3618.     {
  3619.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3620.         return;
  3621.     }

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

  3626.     } else if (upstream->write->timer_set) {
  3627.         ngx_del_timer(upstream->write);
  3628.     }

  3630.     if (upstream->read->eof || upstream->read->error) {
  3631.         flags = NGX_CLOSE_EVENT;

  3633.     } else {
  3634.         flags = 0;
  3635.     }

  3637.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  3638.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3639.         return;
  3640.     }

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

  3645.     } else if (upstream->read->timer_set) {
  3646.         ngx_del_timer(upstream->read);
  3647.     }

  3649.     if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3650.         != NGX_OK)
  3651.     {
  3652.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3653.         return;
  3654.     }

  3656.     if (downstream->read->eof || downstream->read->error) {
  3657.         flags = NGX_CLOSE_EVENT;

  3659.     } else {
  3660.         flags = 0;
  3661.     }

  3663.     if (ngx_handle_read_event(downstream->read, flags) != NGX_OK) {
  3664.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3665.         return;
  3666.     }

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

  3671.     } else if (downstream->write->timer_set) {
  3672.         ngx_del_timer(downstream->write);
  3673.     }
  3674. }


  3677. static void
  3678. ‌ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r)
  3679. {
  3680.     ngx_event_t          *wev;
  3681.     ngx_connection_t     *c;
  3682.     ngx_http_upstream_t  *u;

  3684.     c = r->connection;
  3685.     u = r->upstream;
  3686.     wev = c->write;

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

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

  3693.     if (wev->timedout) {
  3694.         c->timedout = 1;
  3695.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3696.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3697.         return;
  3698.     }

  3700.     ngx_http_upstream_process_non_buffered_request(r, 1);
  3701. }


  3704. static void
  3705. ‌ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  3706.     ngx_http_upstream_t *u)
  3707. {
  3708.     ngx_connection_t  *c;

  3710.     c = u->peer.connection;

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

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

  3717.     if (c->read->timedout) {
  3718.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3719.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3720.         return;
  3721.     }

  3723.     ngx_http_upstream_process_non_buffered_request(r, 0);
  3724. }


  3727. static void
  3728. ‌ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  3729.     ngx_uint_t do_write)
  3730. {
  3731.     size_t                     size;
  3732.     ssize_t                    n;
  3733.     ngx_buf_t                 *b;
  3734.     ngx_int_t                  rc;
  3735.     ngx_uint_t                 flags;
  3736.     ngx_connection_t          *downstream, *upstream;
  3737.     ngx_http_upstream_t       *u;
  3738.     ngx_http_core_loc_conf_t  *clcf;

  3740.     u = r->upstream;
  3741.     downstream = r->connection;
  3742.     upstream = u->peer.connection;

  3744.     b = &u->buffer;

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

  3748.     for ( ;; ) {

  3750.         if (do_write) {

  3752.             if (u->out_bufs || u->busy_bufs || downstream->buffered) {
  3753.                 rc = ngx_http_output_filter(r, u->out_bufs);

  3755.                 if (rc == NGX_ERROR) {
  3756.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3757.                     return;
  3758.                 }

  3760.                 ngx_chain_update_chains(r->pool, &u->free_bufs, &u->busy_bufs,
  3761.                                         &u->out_bufs, u->output.tag);
  3762.             }

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

  3766.                 if (u->length == 0
  3767.                     || (upstream->read->eof && u->length == -1))
  3768.                 {
  3769.                     ngx_http_upstream_finalize_request(r, u, 0);
  3770.                     return;
  3771.                 }

  3773.                 if (upstream->read->eof) {
  3774.                     ngx_log_error(NGX_LOG_ERR, upstream->log, 0,
  3775.                                   "upstream prematurely closed connection");

  3777.                     ngx_http_upstream_finalize_request(r, u,
  3778.                                                        NGX_HTTP_BAD_GATEWAY);
  3779.                     return;
  3780.                 }

  3782.                 if (upstream->read->error || u->error) {
  3783.                     ngx_http_upstream_finalize_request(r, u,
  3784.                                                        NGX_HTTP_BAD_GATEWAY);
  3785.                     return;
  3786.                 }

  3788.                 b->pos = b->start;
  3789.                 b->last = b->start;
  3790.             }
  3791.         }

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

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

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

  3799.             if (n == NGX_AGAIN) {
  3800.                 break;
  3801.             }

  3803.             if (n > 0) {
  3804.                 u->state->bytes_received += n;
  3805.                 u->state->response_length += n;

  3807.                 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  3808.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3809.                     return;
  3810.                 }
  3811.             }

  3813.             do_write = 1;

  3815.             continue;
  3816.         }

  3818.         break;
  3819.     }

  3821.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3823.     if (downstream->data == r) {
  3824.         if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3825.             != NGX_OK)
  3826.         {
  3827.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3828.             return;
  3829.         }
  3830.     }

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

  3835.     } else if (downstream->write->timer_set) {
  3836.         ngx_del_timer(downstream->write);
  3837.     }

  3839.     if (upstream->read->eof || upstream->read->error) {
  3840.         flags = NGX_CLOSE_EVENT;

  3842.     } else {
  3843.         flags = 0;
  3844.     }

  3846.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  3847.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3848.         return;
  3849.     }

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

  3854.     } else if (upstream->read->timer_set) {
  3855.         ngx_del_timer(upstream->read);
  3856.     }
  3857. }


  3860. ngx_int_t
  3861. ‌ngx_http_upstream_non_buffered_filter_init(void *data)
  3862. {
  3863.     return NGX_OK;
  3864. }


  3867. ngx_int_t
  3868. ‌ngx_http_upstream_non_buffered_filter(void *data, ssize_t bytes)
  3869. {
  3870.     ngx_http_request_t  *r = data;

  3872.     ngx_buf_t            *b;
  3873.     ngx_chain_t          *cl, **ll;
  3874.     ngx_http_upstream_t  *u;

  3876.     u = r->upstream;

  3878.     if (u->length == 0) {
  3879.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  3880.                       "upstream sent more data than specified in "
  3881.                       "\"Content-Length\" header");
  3882.         return NGX_OK;
  3883.     }

  3885.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  3886.         ll = &cl->next;
  3887.     }

  3889.     cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  3890.     if (cl == NULL) {
  3891.         return NGX_ERROR;
  3892.     }

  3894.     *ll = cl;

  3896.     cl->buf->flush = 1;
  3897.     cl->buf->memory = 1;

  3899.     b = &u->buffer;

  3901.     cl->buf->pos = b->last;
  3902.     b->last += bytes;
  3903.     cl->buf->last = b->last;
  3904.     cl->buf->tag = u->output.tag;

  3906.     if (u->length == -1) {
  3907.         return NGX_OK;
  3908.     }

  3910.     if (bytes > u->length) {

  3912.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  3913.                       "upstream sent more data than specified in "
  3914.                       "\"Content-Length\" header");

  3916.         cl->buf->last = cl->buf->pos + u->length;
  3917.         u->length = 0;

  3919.         return NGX_OK;
  3920.     }

  3922.     u->length -= bytes;

  3924.     return NGX_OK;
  3925. }


  3928. #if (NGX_THREADS)

  3930. static ngx_int_t
  3931. ‌ngx_http_upstream_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
  3932. {
  3933.     ngx_str_t                  name;
  3934.     ngx_event_pipe_t          *p;
  3935.     ngx_connection_t          *c;
  3936.     ngx_thread_pool_t         *tp;
  3937.     ngx_http_request_t        *r;
  3938.     ngx_http_core_loc_conf_t  *clcf;

  3940.     r = file->thread_ctx;
  3941.     p = r->upstream->pipe;

  3943.     if (r->aio) {
  3944.         /*
  3945.          * tolerate sendfile() calls if another operation is already
  3946.          * running; this can happen due to subrequests, multiple calls
  3947.          * of the next body filter from a filter, or in HTTP/2 due to
  3948.          * a write event on the main connection
  3949.          */

  3951.         c = r->connection;

  3953. #if (NGX_HTTP_V2)
  3954.         if (r->stream) {
  3955.             c = r->stream->connection->connection;
  3956.         }
  3957. #endif

  3959.         if (task == c->sendfile_task) {
  3960.             return NGX_OK;
  3961.         }
  3962.     }

  3964.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  3965.     tp = clcf->thread_pool;

  3967.     if (tp == NULL) {
  3968.         if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
  3969.             != NGX_OK)
  3970.         {
  3971.             return NGX_ERROR;
  3972.         }

  3974.         tp = ngx_thread_pool_get((ngx_cycle_t *) ngx_cycle, &name);

  3976.         if (tp == NULL) {
  3977.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  3978.                           "thread pool \"%V\" not found", &name);
  3979.             return NGX_ERROR;
  3980.         }
  3981.     }

  3983.     task->event.data = r;
  3984.     task->event.handler = ngx_http_upstream_thread_event_handler;

  3986.     if (ngx_thread_task_post(tp, task) != NGX_OK) {
  3987.         return NGX_ERROR;
  3988.     }

  3990.     r->main->blocked++;
  3991.     r->aio = 1;
  3992.     p->aio = 1;

  3994.     ngx_add_timer(&task->event, 60000);

  3996.     return NGX_OK;
  3997. }


  4000. static void
  4001. ‌ngx_http_upstream_thread_event_handler(ngx_event_t *ev)
  4002. {
  4003.     ngx_connection_t    *c;
  4004.     ngx_http_request_t  *r;

  4006.     r = ev->data;
  4007.     c = r->connection;

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

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

  4014.     if (ev->timedout) {
  4015.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  4016.                       "thread operation took too long");
  4017.         ev->timedout = 0;
  4018.         return;
  4019.     }

  4021.     if (ev->timer_set) {
  4022.         ngx_del_timer(ev);
  4023.     }

  4025.     r->main->blocked--;
  4026.     r->aio = 0;

  4028. #if (NGX_HTTP_V2)

  4030.     if (r->stream) {
  4031.         /*
  4032.          * for HTTP/2, update write event to make sure processing will
  4033.          * reach the main connection to handle sendfile() in threads
  4034.          */

  4036.         c->write->ready = 1;
  4037.         c->write->active = 0;
  4038.     }

  4040. #endif

  4042.     if (r->done || r->main->terminated) {
  4043.         /*
  4044.          * trigger connection event handler if the subrequest was
  4045.          * already finalized (this can happen if the handler is used
  4046.          * for sendfile() in threads), or if the request was terminated
  4047.          */

  4049.         c->write->handler(c->write);

  4051.     } else {
  4052.         r->write_event_handler(r);
  4053.         ngx_http_run_posted_requests(c);
  4054.     }
  4055. }

  4057. #endif


  4060. static ngx_int_t
  4061. ‌ngx_http_upstream_output_filter(void *data, ngx_chain_t *chain)
  4062. {
  4063.     ngx_int_t            rc;
  4064.     ngx_event_pipe_t    *p;
  4065.     ngx_http_request_t  *r;

  4067.     r = data;
  4068.     p = r->upstream->pipe;

  4070.     rc = ngx_http_output_filter(r, chain);

  4072.     p->aio = r->aio;

  4074.     return rc;
  4075. }


  4078. static void
  4079. ‌ngx_http_upstream_process_downstream(ngx_http_request_t *r)
  4080. {
  4081.     ngx_event_t          *wev;
  4082.     ngx_connection_t     *c;
  4083.     ngx_event_pipe_t     *p;
  4084.     ngx_http_upstream_t  *u;

  4086.     c = r->connection;
  4087.     u = r->upstream;
  4088.     p = u->pipe;
  4089.     wev = c->write;

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

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

  4096. #if (NGX_THREADS)
  4097.     p->aio = r->aio;
  4098. #endif

  4100.     if (wev->timedout) {

  4102.         p->downstream_error = 1;
  4103.         c->timedout = 1;
  4104.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");

  4106.     } else {

  4108.         if (wev->delayed) {

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

  4113.             if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
  4114.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4115.             }

  4117.             return;
  4118.         }

  4120.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4121.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4122.             return;
  4123.         }
  4124.     }

  4126.     ngx_http_upstream_process_request(r, u);
  4127. }


  4130. static void
  4131. ‌ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  4132.     ngx_http_upstream_t *u)
  4133. {
  4134.     ngx_event_t       *rev;
  4135.     ngx_event_pipe_t  *p;
  4136.     ngx_connection_t  *c;

  4138.     c = u->peer.connection;
  4139.     p = u->pipe;
  4140.     rev = c->read;

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

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

  4147.     if (rev->timedout) {

  4149.         p->upstream_error = 1;
  4150.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");

  4152.     } else {

  4154.         if (rev->delayed) {

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

  4159.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  4160.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4161.             }

  4163.             return;
  4164.         }

  4166.         if (ngx_event_pipe(p, 0) == NGX_ABORT) {
  4167.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4168.             return;
  4169.         }
  4170.     }

  4172.     ngx_http_upstream_process_request(r, u);
  4173. }


  4176. static void
  4177. ‌ngx_http_upstream_process_request(ngx_http_request_t *r,
  4178.     ngx_http_upstream_t *u)
  4179. {
  4180.     ngx_temp_file_t   *tf;
  4181.     ngx_event_pipe_t  *p;

  4183.     p = u->pipe;

  4185. #if (NGX_THREADS)

  4187.     if (p->writing && !p->aio) {

  4189.         /*
  4190.          * make sure to call ngx_event_pipe()
  4191.          * if there is an incomplete aio write
  4192.          */

  4194.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4195.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4196.             return;
  4197.         }
  4198.     }

  4200.     if (p->writing) {
  4201.         return;
  4202.     }

  4204. #endif

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

  4208.         if (u->store) {

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

  4212.                 tf = p->temp_file;

  4214.                 if (u->headers_in.status_n == NGX_HTTP_OK
  4215.                     && (p->upstream_done || p->length == -1)
  4216.                     && (u->headers_in.content_length_n == -1
  4217.                         || u->headers_in.content_length_n == tf->offset))
  4218.                 {
  4219.                     ngx_http_upstream_store(r, u);
  4220.                 }
  4221.             }
  4222.         }

  4224. #if (NGX_HTTP_CACHE)

  4226.         if (u->cacheable) {

  4228.             if (p->upstream_done) {
  4229.                 ngx_http_file_cache_update(r, p->temp_file);

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

  4233.                 tf = p->temp_file;

  4235.                 if (p->length == -1
  4236.                     && (u->headers_in.content_length_n == -1
  4237.                         || u->headers_in.content_length_n
  4238.                            == tf->offset - (off_t) r->cache->body_start))
  4239.                 {
  4240.                     ngx_http_file_cache_update(r, tf);

  4242.                 } else {
  4243.                     ngx_http_file_cache_free(r->cache, tf);
  4244.                 }

  4246.             } else if (p->upstream_error) {
  4247.                 ngx_http_file_cache_free(r->cache, p->temp_file);
  4248.             }
  4249.         }

  4251. #endif

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

  4257.             if (p->upstream_done
  4258.                 || (p->upstream_eof && p->length == -1))
  4259.             {
  4260.                 ngx_http_upstream_finalize_request(r, u, 0);
  4261.                 return;
  4262.             }

  4264.             if (p->upstream_eof) {
  4265.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4266.                               "upstream prematurely closed connection");
  4267.             }

  4269.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  4270.             return;
  4271.         }
  4272.     }

  4274.     if (p->downstream_error) {
  4275.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4276.                        "http upstream downstream error");

  4278.         if (!u->cacheable && !u->store && u->peer.connection) {
  4279.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4280.         }
  4281.     }
  4282. }


  4285. static void
  4286. ‌ngx_http_upstream_store(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4287. {
  4288.     size_t                  root;
  4289.     time_t                  lm;
  4290.     ngx_str_t               path;
  4291.     ngx_temp_file_t        *tf;
  4292.     ngx_ext_rename_file_t   ext;

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

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

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

  4300.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  4301.         if (tf == NULL) {
  4302.             return;
  4303.         }

  4305.         tf->file.fd = NGX_INVALID_FILE;
  4306.         tf->file.log = r->connection->log;
  4307.         tf->path = u->conf->temp_path;
  4308.         tf->pool = r->pool;
  4309.         tf->persistent = 1;

  4311.         if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  4312.                                  tf->persistent, tf->clean, tf->access)
  4313.             != NGX_OK)
  4314.         {
  4315.             return;
  4316.         }

  4318.         u->pipe->temp_file = tf;
  4319.     }

  4321.     ext.access = u->conf->store_access;
  4322.     ext.path_access = u->conf->store_access;
  4323.     ext.time = -1;
  4324.     ext.create_path = 1;
  4325.     ext.delete_file = 1;
  4326.     ext.log = r->connection->log;

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

  4330.         lm = ngx_parse_http_time(u->headers_in.last_modified->value.data,
  4331.                                  u->headers_in.last_modified->value.len);

  4333.         if (lm != NGX_ERROR) {
  4334.             ext.time = lm;
  4335.             ext.fd = tf->file.fd;
  4336.         }
  4337.     }

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

  4341.         if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  4342.             return;
  4343.         }

  4345.     } else {
  4346.         if (ngx_http_script_run(r, &path, u->conf->store_lengths->elts, 0,
  4347.                                 u->conf->store_values->elts)
  4348.             == NULL)
  4349.         {
  4350.             return;
  4351.         }
  4352.     }

  4354.     path.len--;

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

  4360.     if (path.len == 0) {
  4361.         return;
  4362.     }

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

  4366.     u->store = 0;
  4367. }


  4370. static void
  4371. ‌ngx_http_upstream_dummy_handler(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4372. {
  4373.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4374.                    "http upstream dummy handler");
  4375. }


  4378. static void
  4379. ‌ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
  4380.     ngx_uint_t ft_type)
  4381. {
  4382.     ngx_msec_t  timeout;
  4383.     ngx_uint_t  status, state;

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

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

  4390.         if (u->peer.connection) {
  4391.             u->state->bytes_sent = u->peer.connection->sent;
  4392.         }

  4394.         if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_403
  4395.             || ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404)
  4396.         {
  4397.             state = NGX_PEER_NEXT;

  4399.         } else {
  4400.             state = NGX_PEER_FAILED;
  4401.         }

  4403.         u->peer.free(&u->peer, u->peer.data, state);
  4404.         u->peer.sockaddr = NULL;
  4405.     }

  4407.     if (ft_type == NGX_HTTP_UPSTREAM_FT_TIMEOUT) {
  4408.         ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ETIMEDOUT,
  4409.                       "upstream timed out");
  4410.     }

  4412.     if (u->peer.cached && ft_type == NGX_HTTP_UPSTREAM_FT_ERROR) {
  4413.         /* TODO: inform balancer instead */
  4414.         u->peer.tries++;
  4415.     }

  4417.     switch (ft_type) {

  4419.     case NGX_HTTP_UPSTREAM_FT_TIMEOUT:
  4420.     case NGX_HTTP_UPSTREAM_FT_HTTP_504:
  4421.         status = NGX_HTTP_GATEWAY_TIME_OUT;
  4422.         break;

  4424.     case NGX_HTTP_UPSTREAM_FT_HTTP_500:
  4425.         status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4426.         break;

  4428.     case NGX_HTTP_UPSTREAM_FT_HTTP_503:
  4429.         status = NGX_HTTP_SERVICE_UNAVAILABLE;
  4430.         break;

  4432.     case NGX_HTTP_UPSTREAM_FT_HTTP_403:
  4433.         status = NGX_HTTP_FORBIDDEN;
  4434.         break;

  4436.     case NGX_HTTP_UPSTREAM_FT_HTTP_404:
  4437.         status = NGX_HTTP_NOT_FOUND;
  4438.         break;

  4440.     case NGX_HTTP_UPSTREAM_FT_HTTP_429:
  4441.         status = NGX_HTTP_TOO_MANY_REQUESTS;
  4442.         break;

  4444.     /*
  4445.      * NGX_HTTP_UPSTREAM_FT_BUSY_LOCK and NGX_HTTP_UPSTREAM_FT_MAX_WAITING
  4446.      * never reach here
  4447.      */

  4449.     default:
  4450.         status = NGX_HTTP_BAD_GATEWAY;
  4451.     }

  4453.     if (r->connection->error) {
  4454.         ngx_http_upstream_finalize_request(r, u,
  4455.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4456.         return;
  4457.     }

  4459.     u->state->status = status;

  4461.     timeout = u->conf->next_upstream_timeout;

  4463.     if (u->request_sent
  4464.         && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  4465.     {
  4466.         ft_type |= NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;
  4467.     }

  4469.     if (u->peer.tries == 0
  4470.         || ((u->conf->next_upstream & ft_type) != ft_type)
  4471.         || (u->request_sent && r->request_body_no_buffering)
  4472.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  4473.     {
  4474. #if (NGX_HTTP_CACHE)

  4476.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  4477.             && ((u->conf->cache_use_stale & ft_type) || r->cache->stale_error))
  4478.         {
  4479.             ngx_int_t  rc;

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

  4483.             if (rc != NGX_OK) {
  4484.                 ngx_http_upstream_finalize_request(r, u, rc);
  4485.                 return;
  4486.             }

  4488.             u->cache_status = NGX_HTTP_CACHE_STALE;
  4489.             rc = ngx_http_upstream_cache_send(r, u);

  4491.             if (rc == NGX_DONE) {
  4492.                 return;
  4493.             }

  4495.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  4496.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4497.             }

  4499.             ngx_http_upstream_finalize_request(r, u, rc);
  4500.             return;
  4501.         }
  4502. #endif

  4504.         ngx_http_upstream_finalize_request(r, u, status);
  4505.         return;
  4506.     }

  4508.     if (u->peer.connection) {
  4509.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4510.                        "close http upstream connection: %d",
  4511.                        u->peer.connection->fd);
  4512. #if (NGX_HTTP_SSL)

  4514.         if (u->peer.connection->ssl) {
  4515.             u->peer.connection->ssl->no_wait_shutdown = 1;
  4516.             u->peer.connection->ssl->no_send_shutdown = 1;

  4518.             (void) ngx_ssl_shutdown(u->peer.connection);
  4519.         }
  4520. #endif

  4522.         if (u->peer.connection->pool) {
  4523.             ngx_destroy_pool(u->peer.connection->pool);
  4524.         }

  4526.         ngx_close_connection(u->peer.connection);
  4527.         u->peer.connection = NULL;
  4528.     }

  4530.     ngx_http_upstream_connect(r, u);
  4531. }


  4534. static void
  4535. ‌ngx_http_upstream_cleanup(void *data)
  4536. {
  4537.     ngx_http_request_t *r = data;

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

  4542.     ngx_http_upstream_finalize_request(r, r->upstream, NGX_DONE);
  4543. }


  4546. static void
  4547. ‌ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  4548.     ngx_http_upstream_t *u, ngx_int_t rc)
  4549. {
  4550.     ngx_uint_t  flush;

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

  4555.     if (u->cleanup == NULL) {
  4556.         /* the request was already finalized */
  4557.         ngx_http_finalize_request(r, NGX_DONE);
  4558.         return;
  4559.     }

  4561.     *u->cleanup = NULL;
  4562.     u->cleanup = NULL;

  4564.     if (u->resolved && u->resolved->ctx) {
  4565.         ngx_resolve_name_done(u->resolved->ctx);
  4566.         u->resolved->ctx = NULL;
  4567.     }

  4569.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  4570.         u->state->response_time = ngx_current_msec - u->start_time;

  4572.         if (u->pipe && u->pipe->read_length) {
  4573.             u->state->bytes_received += u->pipe->read_length
  4574.                                         - u->pipe->preread_size;
  4575.             u->state->response_length = u->pipe->read_length;
  4576.         }

  4578.         if (u->peer.connection) {
  4579.             u->state->bytes_sent = u->peer.connection->sent;
  4580.         }
  4581.     }

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

  4585.     if (u->peer.free && u->peer.sockaddr) {
  4586.         u->peer.free(&u->peer, u->peer.data, 0);
  4587.         u->peer.sockaddr = NULL;
  4588.     }

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

  4592. #if (NGX_HTTP_SSL)

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

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

  4598.             /*
  4599.              * We send the "close notify" shutdown alert to the upstream only
  4600.              * and do not wait its "close notify" shutdown alert.
  4601.              * It is acceptable according to the TLS standard.
  4602.              */

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

  4606.             (void) ngx_ssl_shutdown(u->peer.connection);
  4607.         }
  4608. #endif

  4610.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4611.                        "close http upstream connection: %d",
  4612.                        u->peer.connection->fd);

  4614.         if (u->peer.connection->pool) {
  4615.             ngx_destroy_pool(u->peer.connection->pool);
  4616.         }

  4618.         ngx_close_connection(u->peer.connection);
  4619.     }

  4621.     u->peer.connection = NULL;

  4623.     if (u->pipe) {
  4624.         u->pipe->upstream = NULL;
  4625.     }

  4627.     if (u->pipe && u->pipe->temp_file) {
  4628.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4629.                        "http upstream temp fd: %d",
  4630.                        u->pipe->temp_file->file.fd);
  4631.     }

  4633.     if (u->store && u->pipe && u->pipe->temp_file
  4634.         && u->pipe->temp_file->file.fd != NGX_INVALID_FILE)
  4635.     {
  4636.         if (ngx_delete_file(u->pipe->temp_file->file.name.data)
  4637.             == NGX_FILE_ERROR)
  4638.         {
  4639.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  4640.                           ngx_delete_file_n " \"%s\" failed",
  4641.                           u->pipe->temp_file->file.name.data);
  4642.         }
  4643.     }

  4645. #if (NGX_HTTP_CACHE)

  4647.     if (r->cache) {

  4649.         if (u->cacheable) {

  4651.             if (rc == NGX_HTTP_BAD_GATEWAY || rc == NGX_HTTP_GATEWAY_TIME_OUT) {
  4652.                 time_t  valid;

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

  4656.                 if (valid) {
  4657.                     r->cache->valid_sec = ngx_time() + valid;
  4658.                     r->cache->error = rc;
  4659.                 }
  4660.             }
  4661.         }

  4663.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  4664.     }

  4666. #endif

  4668.     r->read_event_handler = ngx_http_block_reading;

  4670.     if (rc == NGX_DECLINED) {
  4671.         return;
  4672.     }

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

  4676.     if (!u->header_sent
  4677.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  4678.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST)
  4679.     {
  4680.         ngx_http_finalize_request(r, rc);
  4681.         return;
  4682.     }

  4684.     flush = 0;

  4686.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  4687.         rc = NGX_ERROR;
  4688.         flush = 1;
  4689.     }

  4691.     if (r->header_only
  4692.         || (u->pipe && u->pipe->downstream_error))
  4693.     {
  4694.         ngx_http_finalize_request(r, rc);
  4695.         return;
  4696.     }

  4698.     if (rc == 0) {

  4700.         if (ngx_http_upstream_process_trailers(r, u) != NGX_OK) {
  4701.             ngx_http_finalize_request(r, NGX_ERROR);
  4702.             return;
  4703.         }

  4705.         rc = ngx_http_send_special(r, NGX_HTTP_LAST);

  4707.     } else if (flush) {
  4708.         r->keepalive = 0;
  4709.         rc = ngx_http_send_special(r, NGX_HTTP_FLUSH);
  4710.     }

  4712.     ngx_http_finalize_request(r, rc);
  4713. }


  4716. static ngx_int_t
  4717. ‌ngx_http_upstream_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4718.     ngx_uint_t offset)
  4719. {
  4720.     ngx_table_elt_t  **ph;

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

  4724.     if (*ph) {
  4725.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4726.                       "upstream sent duplicate header line: \"%V: %V\", "
  4727.                       "previous value: \"%V: %V\", ignored",
  4728.                       &h->key, &h->value,
  4729.                       &(*ph)->key, &(*ph)->value);
  4730.         h->hash = 0;
  4731.         return NGX_OK;
  4732.     }

  4734.     *ph = h;
  4735.     h->next = NULL;

  4737.     return NGX_OK;
  4738. }


  4741. static ngx_int_t
  4742. ‌ngx_http_upstream_process_multi_header_lines(ngx_http_request_t *r,
  4743.     ngx_table_elt_t *h, ngx_uint_t offset)
  4744. {
  4745.     ngx_table_elt_t  **ph;

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

  4749.     while (*ph) { ph = &(*ph)->next; }

  4751.     *ph = h;
  4752.     h->next = NULL;

  4754.     return NGX_OK;
  4755. }


  4758. static ngx_int_t
  4759. ‌ngx_http_upstream_ignore_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4760.     ngx_uint_t offset)
  4761. {
  4762.     return NGX_OK;
  4763. }


  4766. static ngx_int_t
  4767. ‌ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  4768.     ngx_table_elt_t *h, ngx_uint_t offset)
  4769. {
  4770.     ngx_http_upstream_t  *u;

  4772.     u = r->upstream;

  4774.     if (u->headers_in.content_length) {
  4775.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4776.                       "upstream sent duplicate header line: \"%V: %V\", "
  4777.                       "previous value: \"%V: %V\"",
  4778.                       &h->key, &h->value,
  4779.                       &u->headers_in.content_length->key,
  4780.                       &u->headers_in.content_length->value);
  4781.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  4782.     }

  4784.     if (u->headers_in.transfer_encoding) {
  4785.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4786.                       "upstream sent \"Content-Length\" and "
  4787.                       "\"Transfer-Encoding\" headers at the same time");
  4788.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  4789.     }

  4791.     h->next = NULL;
  4792.     u->headers_in.content_length = h;
  4793.     u->headers_in.content_length_n = ngx_atoof(h->value.data, h->value.len);

  4795.     if (u->headers_in.content_length_n == NGX_ERROR) {
  4796.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4797.                       "upstream sent invalid \"Content-Length\" header: "
  4798.                       "\"%V: %V\"", &h->key, &h->value);
  4799.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  4800.     }

  4802.     return NGX_OK;
  4803. }


  4806. static ngx_int_t
  4807. ‌ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  4808.     ngx_table_elt_t *h, ngx_uint_t offset)
  4809. {
  4810.     ngx_http_upstream_t  *u;

  4812.     u = r->upstream;

  4814.     if (u->headers_in.last_modified) {
  4815.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4816.                       "upstream sent duplicate header line: \"%V: %V\", "
  4817.                       "previous value: \"%V: %V\", ignored",
  4818.                       &h->key, &h->value,
  4819.                       &u->headers_in.last_modified->key,
  4820.                       &u->headers_in.last_modified->value);
  4821.         h->hash = 0;
  4822.         return NGX_OK;
  4823.     }

  4825.     h->next = NULL;
  4826.     u->headers_in.last_modified = h;
  4827.     u->headers_in.last_modified_time = ngx_parse_http_time(h->value.data,
  4828.                                                            h->value.len);

  4830.     return NGX_OK;
  4831. }


  4834. static ngx_int_t
  4835. ‌ngx_http_upstream_process_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  4836.     ngx_uint_t offset)
  4837. {
  4838.     ngx_table_elt_t      **ph;
  4839.     ngx_http_upstream_t   *u;

  4841.     u = r->upstream;
  4842.     ph = &u->headers_in.set_cookie;

  4844.     while (*ph) { ph = &(*ph)->next; }

  4846.     *ph = h;
  4847.     h->next = NULL;

  4849. #if (NGX_HTTP_CACHE)
  4850.     if (!(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_SET_COOKIE)) {
  4851.         u->cacheable = 0;
  4852.     }
  4853. #endif

  4855.     return NGX_OK;
  4856. }


  4859. static ngx_int_t
  4860. ‌ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  4861.     ngx_table_elt_t *h, ngx_uint_t offset)
  4862. {
  4863.     ngx_table_elt_t      **ph;
  4864.     ngx_http_upstream_t   *u;

  4866.     u = r->upstream;
  4867.     ph = &u->headers_in.cache_control;

  4869.     while (*ph) { ph = &(*ph)->next; }

  4871.     *ph = h;
  4872.     h->next = NULL;

  4874. #if (NGX_HTTP_CACHE)
  4875.     {
  4876.     u_char     *p, *start, *last;
  4877.     ngx_int_t   n;

  4879.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL) {
  4880.         return NGX_OK;
  4881.     }

  4883.     if (r->cache == NULL) {
  4884.         return NGX_OK;
  4885.     }

  4887.     start = h->value.data;
  4888.     last = start + h->value.len;

  4890.     if (r->cache->valid_sec != 0 && u->headers_in.x_accel_expires != NULL) {
  4891.         goto extensions;
  4892.     }

  4894.     if (ngx_strlcasestrn(start, last, (u_char *) "no-cache", 8 - 1) != NULL
  4895.         || ngx_strlcasestrn(start, last, (u_char *) "no-store", 8 - 1) != NULL
  4896.         || ngx_strlcasestrn(start, last, (u_char *) "private", 7 - 1) != NULL)
  4897.     {
  4898.         u->headers_in.no_cache = 1;
  4899.         return NGX_OK;
  4900.     }

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

  4905.     if (p == NULL) {
  4906.         p = ngx_strlcasestrn(start, last, (u_char *) "max-age=", 8 - 1);
  4907.         offset = 8;
  4908.     }

  4910.     if (p) {
  4911.         n = 0;

  4913.         for (p += offset; p < last; p++) {
  4914.             if (*p == ',' || *p == ';' || *p == ' ') {
  4915.                 break;
  4916.             }

  4918.             if (*p >= '0' && *p <= '9') {
  4919.                 n = n * 10 + (*p - '0');
  4920.                 continue;
  4921.             }

  4923.             u->cacheable = 0;
  4924.             return NGX_OK;
  4925.         }

  4927.         if (n == 0) {
  4928.             u->headers_in.no_cache = 1;
  4929.             return NGX_OK;
  4930.         }

  4932.         r->cache->valid_sec = ngx_time() + n;
  4933.         u->headers_in.expired = 0;
  4934.     }

  4936. extensions:

  4938.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-while-revalidate=",
  4939.                          23 - 1);

  4941.     if (p) {
  4942.         n = 0;

  4944.         for (p += 23; p < last; p++) {
  4945.             if (*p == ',' || *p == ';' || *p == ' ') {
  4946.                 break;
  4947.             }

  4949.             if (*p >= '0' && *p <= '9') {
  4950.                 n = n * 10 + (*p - '0');
  4951.                 continue;
  4952.             }

  4954.             u->cacheable = 0;
  4955.             return NGX_OK;
  4956.         }

  4958.         r->cache->updating_sec = n;
  4959.         r->cache->error_sec = n;
  4960.     }

  4962.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-if-error=", 15 - 1);

  4964.     if (p) {
  4965.         n = 0;

  4967.         for (p += 15; p < last; p++) {
  4968.             if (*p == ',' || *p == ';' || *p == ' ') {
  4969.                 break;
  4970.             }

  4972.             if (*p >= '0' && *p <= '9') {
  4973.                 n = n * 10 + (*p - '0');
  4974.                 continue;
  4975.             }

  4977.             u->cacheable = 0;
  4978.             return NGX_OK;
  4979.         }

  4981.         r->cache->error_sec = n;
  4982.     }
  4983.     }
  4984. #endif

  4986.     return NGX_OK;
  4987. }


  4990. static ngx_int_t
  4991. ‌ngx_http_upstream_process_expires(ngx_http_request_t *r, ngx_table_elt_t *h,
  4992.     ngx_uint_t offset)
  4993. {
  4994.     ngx_http_upstream_t  *u;

  4996.     u = r->upstream;

  4998.     if (u->headers_in.expires) {
  4999.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5000.                       "upstream sent duplicate header line: \"%V: %V\", "
  5001.                       "previous value: \"%V: %V\", ignored",
  5002.                       &h->key, &h->value,
  5003.                       &u->headers_in.expires->key,
  5004.                       &u->headers_in.expires->value);
  5005.         h->hash = 0;
  5006.         return NGX_OK;
  5007.     }

  5009.     u->headers_in.expires = h;
  5010.     h->next = NULL;

  5012. #if (NGX_HTTP_CACHE)
  5013.     {
  5014.     time_t  expires;

  5016.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_EXPIRES) {
  5017.         return NGX_OK;
  5018.     }

  5020.     if (r->cache == NULL) {
  5021.         return NGX_OK;
  5022.     }

  5024.     if (r->cache->valid_sec != 0) {
  5025.         return NGX_OK;
  5026.     }

  5028.     expires = ngx_parse_http_time(h->value.data, h->value.len);

  5030.     if (expires == NGX_ERROR || expires < ngx_time()) {
  5031.         u->headers_in.expired = 1;
  5032.         return NGX_OK;
  5033.     }

  5035.     r->cache->valid_sec = expires;
  5036.     }
  5037. #endif

  5039.     return NGX_OK;
  5040. }


  5043. static ngx_int_t
  5044. ‌ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  5045.     ngx_table_elt_t *h, ngx_uint_t offset)
  5046. {
  5047.     ngx_http_upstream_t  *u;

  5049.     u = r->upstream;

  5051.     if (u->headers_in.x_accel_expires) {
  5052.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5053.                       "upstream sent duplicate header line: \"%V: %V\", "
  5054.                       "previous value: \"%V: %V\", ignored",
  5055.                       &h->key, &h->value,
  5056.                       &u->headers_in.x_accel_expires->key,
  5057.                       &u->headers_in.x_accel_expires->value);
  5058.         h->hash = 0;
  5059.         return NGX_OK;
  5060.     }

  5062.     u->headers_in.x_accel_expires = h;
  5063.     h->next = NULL;

  5065. #if (NGX_HTTP_CACHE)
  5066.     {
  5067.     u_char     *p;
  5068.     size_t      len;
  5069.     ngx_int_t   n;

  5071.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES) {
  5072.         return NGX_OK;
  5073.     }

  5075.     if (r->cache == NULL) {
  5076.         return NGX_OK;
  5077.     }

  5079.     len = h->value.len;
  5080.     p = h->value.data;

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

  5085.         switch (n) {
  5086.         case 0:
  5087.             u->cacheable = 0;
  5088.             /* fall through */

  5090.         case NGX_ERROR:
  5091.             return NGX_OK;

  5093.         default:
  5094.             r->cache->valid_sec = ngx_time() + n;
  5095.             u->headers_in.no_cache = 0;
  5096.             u->headers_in.expired = 0;
  5097.             return NGX_OK;
  5098.         }
  5099.     }

  5101.     p++;
  5102.     len--;

  5104.     n = ngx_atoi(p, len);

  5106.     if (n != NGX_ERROR) {
  5107.         r->cache->valid_sec = n;
  5108.         u->headers_in.no_cache = 0;
  5109.         u->headers_in.expired = 0;
  5110.     }
  5111.     }
  5112. #endif

  5114.     return NGX_OK;
  5115. }


  5118. static ngx_int_t
  5119. ‌ngx_http_upstream_process_limit_rate(ngx_http_request_t *r, ngx_table_elt_t *h,
  5120.     ngx_uint_t offset)
  5121. {
  5122.     ngx_int_t             n;
  5123.     ngx_http_upstream_t  *u;

  5125.     u = r->upstream;

  5127.     if (u->headers_in.x_accel_limit_rate) {
  5128.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5129.                       "upstream sent duplicate header line: \"%V: %V\", "
  5130.                       "previous value: \"%V: %V\", ignored",
  5131.                       &h->key, &h->value,
  5132.                       &u->headers_in.x_accel_limit_rate->key,
  5133.                       &u->headers_in.x_accel_limit_rate->value);
  5134.         h->hash = 0;
  5135.         return NGX_OK;
  5136.     }

  5138.     u->headers_in.x_accel_limit_rate = h;
  5139.     h->next = NULL;

  5141.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE) {
  5142.         return NGX_OK;
  5143.     }

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

  5147.     if (n != NGX_ERROR) {
  5148.         r->limit_rate = (size_t) n;
  5149.         r->limit_rate_set = 1;
  5150.     }

  5152.     return NGX_OK;
  5153. }


  5156. static ngx_int_t
  5157. ‌ngx_http_upstream_process_buffering(ngx_http_request_t *r, ngx_table_elt_t *h,
  5158.     ngx_uint_t offset)
  5159. {
  5160.     u_char                c0, c1, c2;
  5161.     ngx_http_upstream_t  *u;

  5163.     u = r->upstream;

  5165.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING) {
  5166.         return NGX_OK;
  5167.     }

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

  5171.         if (h->value.len == 2) {
  5172.             c0 = ngx_tolower(h->value.data[0]);
  5173.             c1 = ngx_tolower(h->value.data[1]);

  5175.             if (c0 == 'n' && c1 == 'o') {
  5176.                 u->buffering = 0;
  5177.             }

  5179.         } else if (h->value.len == 3) {
  5180.             c0 = ngx_tolower(h->value.data[0]);
  5181.             c1 = ngx_tolower(h->value.data[1]);
  5182.             c2 = ngx_tolower(h->value.data[2]);

  5184.             if (c0 == 'y' && c1 == 'e' && c2 == 's') {
  5185.                 u->buffering = 1;
  5186.             }
  5187.         }
  5188.     }

  5190.     return NGX_OK;
  5191. }


  5194. static ngx_int_t
  5195. ‌ngx_http_upstream_process_charset(ngx_http_request_t *r, ngx_table_elt_t *h,
  5196.     ngx_uint_t offset)
  5197. {
  5198.     ngx_http_upstream_t  *u;

  5200.     u = r->upstream;

  5202.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_CHARSET) {
  5203.         return NGX_OK;
  5204.     }

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

  5208.     return NGX_OK;
  5209. }


  5212. static ngx_int_t
  5213. ‌ngx_http_upstream_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  5214.     ngx_uint_t offset)
  5215. {
  5216.     ngx_table_elt_t      **ph;
  5217.     ngx_http_upstream_t   *u;

  5219.     u = r->upstream;
  5220.     ph = &u->headers_in.connection;

  5222.     while (*ph) { ph = &(*ph)->next; }

  5224.     *ph = h;
  5225.     h->next = NULL;

  5227.     if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
  5228.                          (u_char *) "close", 5 - 1)
  5229.         != NULL)
  5230.     {
  5231.         u->headers_in.connection_close = 1;
  5232.     }

  5234.     return NGX_OK;
  5235. }


  5238. static ngx_int_t
  5239. ‌ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  5240.     ngx_table_elt_t *h, ngx_uint_t offset)
  5241. {
  5242.     ngx_http_upstream_t  *u;

  5244.     u = r->upstream;

  5246.     if (u->headers_in.transfer_encoding) {
  5247.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5248.                       "upstream sent duplicate header line: \"%V: %V\", "
  5249.                       "previous value: \"%V: %V\"",
  5250.                       &h->key, &h->value,
  5251.                       &u->headers_in.transfer_encoding->key,
  5252.                       &u->headers_in.transfer_encoding->value);
  5253.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5254.     }

  5256.     if (u->headers_in.content_length) {
  5257.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5258.                       "upstream sent \"Content-Length\" and "
  5259.                       "\"Transfer-Encoding\" headers at the same time");
  5260.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5261.     }

  5263.     u->headers_in.transfer_encoding = h;
  5264.     h->next = NULL;

  5266.     if (h->value.len == 7
  5267.         && ngx_strncasecmp(h->value.data, (u_char *) "chunked", 7) == 0)
  5268.     {
  5269.         u->headers_in.chunked = 1;

  5271.     } else {
  5272.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5273.                       "upstream sent unknown \"Transfer-Encoding\": \"%V\"",
  5274.                       &h->value);
  5275.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5276.     }

  5278.     return NGX_OK;
  5279. }


  5282. static ngx_int_t
  5283. ‌ngx_http_upstream_process_vary(ngx_http_request_t *r,
  5284.     ngx_table_elt_t *h, ngx_uint_t offset)
  5285. {
  5286.     ngx_table_elt_t      **ph;
  5287.     ngx_http_upstream_t   *u;

  5289.     u = r->upstream;
  5290.     ph = &u->headers_in.vary;

  5292.     while (*ph) { ph = &(*ph)->next; }

  5294.     *ph = h;
  5295.     h->next = NULL;

  5297. #if (NGX_HTTP_CACHE)
  5298.     {
  5299.     u_char     *p;
  5300.     size_t      len;
  5301.     ngx_str_t   vary;

  5303.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_VARY) {
  5304.         return NGX_OK;
  5305.     }

  5307.     if (r->cache == NULL || !u->cacheable) {
  5308.         return NGX_OK;
  5309.     }

  5311.     if (h->value.len == 1 && h->value.data[0] == '*') {
  5312.         u->cacheable = 0;
  5313.         return NGX_OK;
  5314.     }

  5316.     if (u->headers_in.vary->next) {

  5318.         len = 0;

  5320.         for (h = u->headers_in.vary; h; h = h->next) {
  5321.             len += h->value.len + 2;
  5322.         }

  5324.         len -= 2;

  5326.         p = ngx_pnalloc(r->pool, len);
  5327.         if (p == NULL) {
  5328.             return NGX_ERROR;
  5329.         }

  5331.         vary.len = len;
  5332.         vary.data = p;

  5334.         for (h = u->headers_in.vary; h; h = h->next) {
  5335.             p = ngx_copy(p, h->value.data, h->value.len);

  5337.             if (h->next == NULL) {
  5338.                 break;
  5339.             }

  5341.             *p++ = ','; *p++ = ' ';
  5342.         }

  5344.     } else {
  5345.         vary = h->value;
  5346.     }

  5348.     if (vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  5349.         u->cacheable = 0;
  5350.     }

  5352.     r->cache->vary = vary;
  5353.     }
  5354. #endif

  5356.     return NGX_OK;
  5357. }


  5360. static ngx_int_t
  5361. ‌ngx_http_upstream_copy_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  5362.     ngx_uint_t offset)
  5363. {
  5364.     ngx_table_elt_t  *ho, **ph;

  5366.     ho = ngx_list_push(&r->headers_out.headers);
  5367.     if (ho == NULL) {
  5368.         return NGX_ERROR;
  5369.     }

  5371.     *ho = *h;

  5373.     if (offset) {
  5374.         ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);
  5375.         *ph = ho;
  5376.         ho->next = NULL;
  5377.     }

  5379.     return NGX_OK;
  5380. }


  5383. static ngx_int_t
  5384. ‌ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  5385.     ngx_table_elt_t *h, ngx_uint_t offset)
  5386. {
  5387.     ngx_table_elt_t  *ho, **ph;

  5389.     ho = ngx_list_push(&r->headers_out.headers);
  5390.     if (ho == NULL) {
  5391.         return NGX_ERROR;
  5392.     }

  5394.     *ho = *h;

  5396.     ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);

  5398.     while (*ph) { ph = &(*ph)->next; }

  5400.     *ph = ho;
  5401.     ho->next = NULL;

  5403.     return NGX_OK;
  5404. }


  5407. static ngx_int_t
  5408. ‌ngx_http_upstream_copy_content_type(ngx_http_request_t *r, ngx_table_elt_t *h,
  5409.     ngx_uint_t offset)
  5410. {
  5411.     u_char  *p, *last;

  5413.     r->headers_out.content_type_len = h->value.len;
  5414.     r->headers_out.content_type = h->value;
  5415.     r->headers_out.content_type_lowcase = NULL;

  5417.     for (p = h->value.data; *p; p++) {

  5419.         if (*p != ';') {
  5420.             continue;
  5421.         }

  5423.         last = p;

  5425.         while (*++p == ' ') { /* void */ }

  5427.         if (*p == '\0') {
  5428.             return NGX_OK;
  5429.         }

  5431.         if (ngx_strncasecmp(p, (u_char *) "charset=", 8) != 0) {
  5432.             continue;
  5433.         }

  5435.         p += 8;

  5437.         r->headers_out.content_type_len = last - h->value.data;

  5439.         if (*p == '"') {
  5440.             p++;
  5441.         }

  5443.         last = h->value.data + h->value.len;

  5445.         if (*(last - 1) == '"') {
  5446.             last--;
  5447.         }

  5449.         r->headers_out.charset.len = last - p;
  5450.         r->headers_out.charset.data = p;

  5452.         return NGX_OK;
  5453.     }

  5455.     return NGX_OK;
  5456. }


  5459. static ngx_int_t
  5460. ‌ngx_http_upstream_copy_last_modified(ngx_http_request_t *r, ngx_table_elt_t *h,
  5461.     ngx_uint_t offset)
  5462. {
  5463.     ngx_table_elt_t  *ho;

  5465.     ho = ngx_list_push(&r->headers_out.headers);
  5466.     if (ho == NULL) {
  5467.         return NGX_ERROR;
  5468.     }

  5470.     *ho = *h;
  5471.     ho->next = NULL;

  5473.     r->headers_out.last_modified = ho;
  5474.     r->headers_out.last_modified_time =
  5475.                                     r->upstream->headers_in.last_modified_time;

  5477.     return NGX_OK;
  5478. }


  5481. static ngx_int_t
  5482. ‌ngx_http_upstream_rewrite_location(ngx_http_request_t *r, ngx_table_elt_t *h,
  5483.     ngx_uint_t offset)
  5484. {
  5485.     ngx_int_t         rc;
  5486.     ngx_table_elt_t  *ho;

  5488.     ho = ngx_list_push(&r->headers_out.headers);
  5489.     if (ho == NULL) {
  5490.         return NGX_ERROR;
  5491.     }

  5493.     *ho = *h;
  5494.     ho->next = NULL;

  5496.     if (r->upstream->rewrite_redirect) {
  5497.         rc = r->upstream->rewrite_redirect(r, ho, 0);

  5499.         if (rc == NGX_DECLINED) {
  5500.             return NGX_OK;
  5501.         }

  5503.         if (rc == NGX_OK) {
  5504.             r->headers_out.location = ho;

  5506.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5507.                            "rewritten location: \"%V\"", &ho->value);
  5508.         }

  5510.         return rc;
  5511.     }

  5513.     if (ho->value.data[0] != '/') {
  5514.         r->headers_out.location = ho;
  5515.     }

  5517.     /*
  5518.      * we do not set r->headers_out.location here to avoid handling
  5519.      * relative redirects in ngx_http_header_filter()
  5520.      */

  5522.     return NGX_OK;
  5523. }


  5526. static ngx_int_t
  5527. ‌ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r, ngx_table_elt_t *h,
  5528.     ngx_uint_t offset)
  5529. {
  5530.     u_char           *p;
  5531.     ngx_int_t         rc;
  5532.     ngx_table_elt_t  *ho;

  5534.     ho = ngx_list_push(&r->headers_out.headers);
  5535.     if (ho == NULL) {
  5536.         return NGX_ERROR;
  5537.     }

  5539.     *ho = *h;
  5540.     ho->next = NULL;

  5542.     if (r->upstream->rewrite_redirect) {

  5544.         p = ngx_strcasestrn(ho->value.data, "url=", 4 - 1);

  5546.         if (p) {
  5547.             rc = r->upstream->rewrite_redirect(r, ho, p + 4 - ho->value.data);

  5549.         } else {
  5550.             return NGX_OK;
  5551.         }

  5553.         if (rc == NGX_DECLINED) {
  5554.             return NGX_OK;
  5555.         }

  5557.         if (rc == NGX_OK) {
  5558.             r->headers_out.refresh = ho;

  5560.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5561.                            "rewritten refresh: \"%V\"", &ho->value);
  5562.         }

  5564.         return rc;
  5565.     }

  5567.     r->headers_out.refresh = ho;

  5569.     return NGX_OK;
  5570. }


  5573. static ngx_int_t
  5574. ‌ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5575.     ngx_uint_t offset)
  5576. {
  5577.     ngx_int_t         rc;
  5578.     ngx_table_elt_t  *ho;

  5580.     ho = ngx_list_push(&r->headers_out.headers);
  5581.     if (ho == NULL) {
  5582.         return NGX_ERROR;
  5583.     }

  5585.     *ho = *h;
  5586.     ho->next = NULL;

  5588.     if (r->upstream->rewrite_cookie) {
  5589.         rc = r->upstream->rewrite_cookie(r, ho);

  5591.         if (rc == NGX_DECLINED) {
  5592.             return NGX_OK;
  5593.         }

  5595. #if (NGX_DEBUG)
  5596.         if (rc == NGX_OK) {
  5597.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5598.                            "rewritten cookie: \"%V\"", &ho->value);
  5599.         }
  5600. #endif

  5602.         return rc;
  5603.     }

  5605.     return NGX_OK;
  5606. }


  5609. static ngx_int_t
  5610. ‌ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  5611.     ngx_table_elt_t *h, ngx_uint_t offset)
  5612. {
  5613.     ngx_table_elt_t  *ho;

  5615.     if (r->upstream->conf->force_ranges) {
  5616.         return NGX_OK;
  5617.     }

  5619. #if (NGX_HTTP_CACHE)

  5621.     if (r->cached) {
  5622.         r->allow_ranges = 1;
  5623.         return NGX_OK;
  5624.     }

  5626.     if (r->upstream->cacheable) {
  5627.         r->allow_ranges = 1;
  5628.         r->single_range = 1;
  5629.         return NGX_OK;
  5630.     }

  5632. #endif

  5634.     ho = ngx_list_push(&r->headers_out.headers);
  5635.     if (ho == NULL) {
  5636.         return NGX_ERROR;
  5637.     }

  5639.     *ho = *h;
  5640.     ho->next = NULL;

  5642.     r->headers_out.accept_ranges = ho;

  5644.     return NGX_OK;
  5645. }


  5648. static ngx_int_t
  5649. ‌ngx_http_upstream_add_variables(ngx_conf_t *cf)
  5650. {
  5651.     ngx_http_variable_t  *var, *v;

  5653.     for (v = ngx_http_upstream_vars; v->name.len; v++) {
  5654.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  5655.         if (var == NULL) {
  5656.             return NGX_ERROR;
  5657.         }

  5659.         var->get_handler = v->get_handler;
  5660.         var->data = v->data;
  5661.     }

  5663.     return NGX_OK;
  5664. }


  5667. static ngx_int_t
  5668. ‌ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  5669.     ngx_http_variable_value_t *v, uintptr_t data)
  5670. {
  5671.     u_char                     *p;
  5672.     size_t                      len;
  5673.     ngx_uint_t                  i;
  5674.     ngx_http_upstream_state_t  *state;

  5676.     v->valid = 1;
  5677.     v->no_cacheable = 0;
  5678.     v->not_found = 0;

  5680.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5681.         v->not_found = 1;
  5682.         return NGX_OK;
  5683.     }

  5685.     len = 0;
  5686.     state = r->upstream_states->elts;

  5688.     for (i = 0; i < r->upstream_states->nelts; i++) {
  5689.         if (state[i].peer) {
  5690.             len += state[i].peer->len + 2;

  5692.         } else {
  5693.             len += 3;
  5694.         }
  5695.     }

  5697.     p = ngx_pnalloc(r->pool, len);
  5698.     if (p == NULL) {
  5699.         return NGX_ERROR;
  5700.     }

  5702.     v->data = p;

  5704.     i = 0;

  5706.     for ( ;; ) {
  5707.         if (state[i].peer) {
  5708.             p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
  5709.         }

  5711.         if (++i == r->upstream_states->nelts) {
  5712.             break;
  5713.         }

  5715.         if (state[i].peer) {
  5716.             *p++ = ',';
  5717.             *p++ = ' ';

  5719.         } else {
  5720.             *p++ = ' ';
  5721.             *p++ = ':';
  5722.             *p++ = ' ';

  5724.             if (++i == r->upstream_states->nelts) {
  5725.                 break;
  5726.             }

  5728.             continue;
  5729.         }
  5730.     }

  5732.     v->len = p - v->data;

  5734.     return NGX_OK;
  5735. }


  5738. static ngx_int_t
  5739. ‌ngx_http_upstream_status_variable(ngx_http_request_t *r,
  5740.     ngx_http_variable_value_t *v, uintptr_t data)
  5741. {
  5742.     u_char                     *p;
  5743.     size_t                      len;
  5744.     ngx_uint_t                  i;
  5745.     ngx_http_upstream_state_t  *state;

  5747.     v->valid = 1;
  5748.     v->no_cacheable = 0;
  5749.     v->not_found = 0;

  5751.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5752.         v->not_found = 1;
  5753.         return NGX_OK;
  5754.     }

  5756.     len = r->upstream_states->nelts * (3 + 2);

  5758.     p = ngx_pnalloc(r->pool, len);
  5759.     if (p == NULL) {
  5760.         return NGX_ERROR;
  5761.     }

  5763.     v->data = p;

  5765.     i = 0;
  5766.     state = r->upstream_states->elts;

  5768.     for ( ;; ) {
  5769.         if (state[i].status) {
  5770.             p = ngx_sprintf(p, "%ui", state[i].status);

  5772.         } else {
  5773.             *p++ = '-';
  5774.         }

  5776.         if (++i == r->upstream_states->nelts) {
  5777.             break;
  5778.         }

  5780.         if (state[i].peer) {
  5781.             *p++ = ',';
  5782.             *p++ = ' ';

  5784.         } else {
  5785.             *p++ = ' ';
  5786.             *p++ = ':';
  5787.             *p++ = ' ';

  5789.             if (++i == r->upstream_states->nelts) {
  5790.                 break;
  5791.             }

  5793.             continue;
  5794.         }
  5795.     }

  5797.     v->len = p - v->data;

  5799.     return NGX_OK;
  5800. }


  5803. static ngx_int_t
  5804. ‌ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  5805.     ngx_http_variable_value_t *v, uintptr_t data)
  5806. {
  5807.     u_char                     *p;
  5808.     size_t                      len;
  5809.     ngx_uint_t                  i;
  5810.     ngx_msec_int_t              ms;
  5811.     ngx_http_upstream_state_t  *state;

  5813.     v->valid = 1;
  5814.     v->no_cacheable = 0;
  5815.     v->not_found = 0;

  5817.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5818.         v->not_found = 1;
  5819.         return NGX_OK;
  5820.     }

  5822.     len = r->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);

  5824.     p = ngx_pnalloc(r->pool, len);
  5825.     if (p == NULL) {
  5826.         return NGX_ERROR;
  5827.     }

  5829.     v->data = p;

  5831.     i = 0;
  5832.     state = r->upstream_states->elts;

  5834.     for ( ;; ) {

  5836.         if (data == 1) {
  5837.             ms = state[i].header_time;

  5839.         } else if (data == 2) {
  5840.             ms = state[i].connect_time;

  5842.         } else {
  5843.             ms = state[i].response_time;
  5844.         }

  5846.         if (ms != -1) {
  5847.             ms = ngx_max(ms, 0);
  5848.             p = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000);

  5850.         } else {
  5851.             *p++ = '-';
  5852.         }

  5854.         if (++i == r->upstream_states->nelts) {
  5855.             break;
  5856.         }

  5858.         if (state[i].peer) {
  5859.             *p++ = ',';
  5860.             *p++ = ' ';

  5862.         } else {
  5863.             *p++ = ' ';
  5864.             *p++ = ':';
  5865.             *p++ = ' ';

  5867.             if (++i == r->upstream_states->nelts) {
  5868.                 break;
  5869.             }

  5871.             continue;
  5872.         }
  5873.     }

  5875.     v->len = p - v->data;

  5877.     return NGX_OK;
  5878. }


  5881. static ngx_int_t
  5882. ‌ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
  5883.     ngx_http_variable_value_t *v, uintptr_t data)
  5884. {
  5885.     u_char                     *p;
  5886.     size_t                      len;
  5887.     ngx_uint_t                  i;
  5888.     ngx_http_upstream_state_t  *state;

  5890.     v->valid = 1;
  5891.     v->no_cacheable = 0;
  5892.     v->not_found = 0;

  5894.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5895.         v->not_found = 1;
  5896.         return NGX_OK;
  5897.     }

  5899.     len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);

  5901.     p = ngx_pnalloc(r->pool, len);
  5902.     if (p == NULL) {
  5903.         return NGX_ERROR;
  5904.     }

  5906.     v->data = p;

  5908.     i = 0;
  5909.     state = r->upstream_states->elts;

  5911.     for ( ;; ) {

  5913.         if (data == 1) {
  5914.             p = ngx_sprintf(p, "%O", state[i].bytes_received);

  5916.         } else if (data == 2) {
  5917.             p = ngx_sprintf(p, "%O", state[i].bytes_sent);

  5919.         } else {
  5920.             p = ngx_sprintf(p, "%O", state[i].response_length);
  5921.         }

  5923.         if (++i == r->upstream_states->nelts) {
  5924.             break;
  5925.         }

  5927.         if (state[i].peer) {
  5928.             *p++ = ',';
  5929.             *p++ = ' ';

  5931.         } else {
  5932.             *p++ = ' ';
  5933.             *p++ = ':';
  5934.             *p++ = ' ';

  5936.             if (++i == r->upstream_states->nelts) {
  5937.                 break;
  5938.             }

  5940.             continue;
  5941.         }
  5942.     }

  5944.     v->len = p - v->data;

  5946.     return NGX_OK;
  5947. }


  5950. static ngx_int_t
  5951. ‌ngx_http_upstream_header_variable(ngx_http_request_t *r,
  5952.     ngx_http_variable_value_t *v, uintptr_t data)
  5953. {
  5954.     if (r->upstream == NULL) {
  5955.         v->not_found = 1;
  5956.         return NGX_OK;
  5957.     }

  5959.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  5960.                                          &r->upstream->headers_in.headers.part,
  5961.                                          sizeof("upstream_http_") - 1);
  5962. }


  5965. static ngx_int_t
  5966. ‌ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  5967.     ngx_http_variable_value_t *v, uintptr_t data)
  5968. {
  5969.     if (r->upstream == NULL) {
  5970.         v->not_found = 1;
  5971.         return NGX_OK;
  5972.     }

  5974.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  5975.                                         &r->upstream->headers_in.trailers.part,
  5976.                                         sizeof("upstream_trailer_") - 1);
  5977. }


  5980. static ngx_int_t
  5981. ‌ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  5982.     ngx_http_variable_value_t *v, uintptr_t data)
  5983. {
  5984.     ngx_str_t  *name = (ngx_str_t *) data;

  5986.     ngx_str_t   cookie, s;

  5988.     if (r->upstream == NULL) {
  5989.         v->not_found = 1;
  5990.         return NGX_OK;
  5991.     }

  5993.     s.len = name->len - (sizeof("upstream_cookie_") - 1);
  5994.     s.data = name->data + sizeof("upstream_cookie_") - 1;

  5996.     if (ngx_http_parse_set_cookie_lines(r, r->upstream->headers_in.set_cookie,
  5997.                                         &s, &cookie)
  5998.         == NULL)
  5999.     {
  6000.         v->not_found = 1;
  6001.         return NGX_OK;
  6002.     }

  6004.     v->len = cookie.len;
  6005.     v->valid = 1;
  6006.     v->no_cacheable = 0;
  6007.     v->not_found = 0;
  6008.     v->data = cookie.data;

  6010.     return NGX_OK;
  6011. }


  6014. #if (NGX_HTTP_CACHE)

  6016. static ngx_int_t
  6017. ‌ngx_http_upstream_cache_status(ngx_http_request_t *r,
  6018.     ngx_http_variable_value_t *v, uintptr_t data)
  6019. {
  6020.     ngx_uint_t  n;

  6022.     if (r->upstream == NULL || r->upstream->cache_status == 0) {
  6023.         v->not_found = 1;
  6024.         return NGX_OK;
  6025.     }

  6027.     n = r->upstream->cache_status - 1;

  6029.     v->valid = 1;
  6030.     v->no_cacheable = 0;
  6031.     v->not_found = 0;
  6032.     v->len = ngx_http_cache_status[n].len;
  6033.     v->data = ngx_http_cache_status[n].data;

  6035.     return NGX_OK;
  6036. }


  6039. static ngx_int_t
  6040. ‌ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  6041.     ngx_http_variable_value_t *v, uintptr_t data)
  6042. {
  6043.     u_char  *p;

  6045.     if (r->upstream == NULL
  6046.         || !r->upstream->conf->cache_revalidate
  6047.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6048.         || r->cache->last_modified == -1)
  6049.     {
  6050.         v->not_found = 1;
  6051.         return NGX_OK;
  6052.     }

  6054.     p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  6055.     if (p == NULL) {
  6056.         return NGX_ERROR;
  6057.     }

  6059.     v->len = ngx_http_time(p, r->cache->last_modified) - p;
  6060.     v->valid = 1;
  6061.     v->no_cacheable = 0;
  6062.     v->not_found = 0;
  6063.     v->data = p;

  6065.     return NGX_OK;
  6066. }


  6069. static ngx_int_t
  6070. ‌ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  6071.     ngx_http_variable_value_t *v, uintptr_t data)
  6072. {
  6073.     if (r->upstream == NULL
  6074.         || !r->upstream->conf->cache_revalidate
  6075.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6076.         || r->cache->etag.len == 0)
  6077.     {
  6078.         v->not_found = 1;
  6079.         return NGX_OK;
  6080.     }

  6082.     v->valid = 1;
  6083.     v->no_cacheable = 0;
  6084.     v->not_found = 0;
  6085.     v->len = r->cache->etag.len;
  6086.     v->data = r->cache->etag.data;

  6088.     return NGX_OK;
  6089. }

  6091. #endif


  6094. static char *
  6095. ‌ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  6096. {
  6097.     char                          *rv;
  6098.     void                          *mconf;
  6099.     ngx_str_t                     *value;
  6100.     ngx_url_t                      u;
  6101.     ngx_uint_t                     m;
  6102.     ngx_conf_t                     pcf;
  6103.     ngx_http_module_t             *module;
  6104.     ngx_http_conf_ctx_t           *ctx, *http_ctx;
  6105.     ngx_http_upstream_srv_conf_t  *uscf;

  6107.     ngx_memzero(&u, sizeof(ngx_url_t));

  6109.     value = cf->args->elts;
  6110.     u.host = value[1];
  6111.     u.no_resolve = 1;
  6112.     u.no_port = 1;

  6114.     uscf = ngx_http_upstream_add(cf, &u, NGX_HTTP_UPSTREAM_CREATE
  6115.                                          |NGX_HTTP_UPSTREAM_MODIFY
  6116.                                          |NGX_HTTP_UPSTREAM_WEIGHT
  6117.                                          |NGX_HTTP_UPSTREAM_MAX_CONNS
  6118.                                          |NGX_HTTP_UPSTREAM_MAX_FAILS
  6119.                                          |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  6120.                                          |NGX_HTTP_UPSTREAM_DOWN
  6121.                                          |NGX_HTTP_UPSTREAM_BACKUP);
  6122.     if (uscf == NULL) {
  6123.         return NGX_CONF_ERROR;
  6124.     }


  6127.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  6128.     if (ctx == NULL) {
  6129.         return NGX_CONF_ERROR;
  6130.     }

  6132.     http_ctx = cf->ctx;
  6133.     ctx->main_conf = http_ctx->main_conf;

  6135.     /* the upstream{}'s srv_conf */

  6137.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6138.     if (ctx->srv_conf == NULL) {
  6139.         return NGX_CONF_ERROR;
  6140.     }

  6142.     ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;

  6144.     uscf->srv_conf = ctx->srv_conf;


  6147.     /* the upstream{}'s loc_conf */

  6149.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6150.     if (ctx->loc_conf == NULL) {
  6151.         return NGX_CONF_ERROR;
  6152.     }

  6154.     for (m = 0; cf->cycle->modules[m]; m++) {
  6155.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  6156.             continue;
  6157.         }

  6159.         module = cf->cycle->modules[m]->ctx;

  6161.         if (module->create_srv_conf) {
  6162.             mconf = module->create_srv_conf(cf);
  6163.             if (mconf == NULL) {
  6164.                 return NGX_CONF_ERROR;
  6165.             }

  6167.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6168.         }

  6170.         if (module->create_loc_conf) {
  6171.             mconf = module->create_loc_conf(cf);
  6172.             if (mconf == NULL) {
  6173.                 return NGX_CONF_ERROR;
  6174.             }

  6176.             ctx->loc_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6177.         }
  6178.     }

  6180.     uscf->servers = ngx_array_create(cf->pool, 4,
  6181.                                      sizeof(ngx_http_upstream_server_t));
  6182.     if (uscf->servers == NULL) {
  6183.         return NGX_CONF_ERROR;
  6184.     }


  6187.     /* parse inside upstream{} */

  6189.     pcf = *cf;
  6190.     cf->ctx = ctx;
  6191.     cf->cmd_type = NGX_HTTP_UPS_CONF;

  6193.     rv = ngx_conf_parse(cf, NULL);

  6195.     *cf = pcf;

  6197.     if (rv != NGX_CONF_OK) {
  6198.         return rv;
  6199.     }

  6201.     if (uscf->servers->nelts == 0) {
  6202.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6203.                            "no servers are inside upstream");
  6204.         return NGX_CONF_ERROR;
  6205.     }

  6207.     return rv;
  6208. }


  6211. static char *
  6212. ‌ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6213. {
  6214.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6216.     time_t                       fail_timeout;
  6217.     ngx_str_t                   *value, s;
  6218.     ngx_url_t                    u;
  6219.     ngx_int_t                    weight, max_conns, max_fails;
  6220.     ngx_uint_t                   i;
  6221. #if (NGX_HTTP_UPSTREAM_ZONE)
  6222.     ngx_uint_t                   resolve;
  6223. #endif
  6224.     ngx_http_upstream_server_t  *us;

  6226.     us = ngx_array_push(uscf->servers);
  6227.     if (us == NULL) {
  6228.         return NGX_CONF_ERROR;
  6229.     }

  6231.     ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6233.     value = cf->args->elts;

  6235.     weight = 1;
  6236.     max_conns = 0;
  6237.     max_fails = 1;
  6238.     fail_timeout = 10;
  6239. #if (NGX_HTTP_UPSTREAM_ZONE)
  6240.     resolve = 0;
  6241. #endif

  6243.     for (i = 2; i < cf->args->nelts; i++) {

  6245.         if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {

  6247.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_WEIGHT)) {
  6248.                 goto not_supported;
  6249.             }

  6251.             weight = ngx_atoi(&value[i].data[7], value[i].len - 7);

  6253.             if (weight == NGX_ERROR || weight == 0) {
  6254.                 goto invalid;
  6255.             }

  6257.             continue;
  6258.         }

  6260.         if (ngx_strncmp(value[i].data, "max_conns=", 10) == 0) {

  6262.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_CONNS)) {
  6263.                 goto not_supported;
  6264.             }

  6266.             max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6268.             if (max_conns == NGX_ERROR) {
  6269.                 goto invalid;
  6270.             }

  6272.             continue;
  6273.         }

  6275.         if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {

  6277.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_FAILS)) {
  6278.                 goto not_supported;
  6279.             }

  6281.             max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6283.             if (max_fails == NGX_ERROR) {
  6284.                 goto invalid;
  6285.             }

  6287.             continue;
  6288.         }

  6290.         if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {

  6292.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_FAIL_TIMEOUT)) {
  6293.                 goto not_supported;
  6294.             }

  6296.             s.len = value[i].len - 13;
  6297.             s.data = &value[i].data[13];

  6299.             fail_timeout = ngx_parse_time(&s, 1);

  6301.             if (fail_timeout == (time_t) NGX_ERROR) {
  6302.                 goto invalid;
  6303.             }

  6305.             continue;
  6306.         }

  6308.         if (ngx_strcmp(value[i].data, "backup") == 0) {

  6310.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  6311.                 goto not_supported;
  6312.             }

  6314.             us->backup = 1;

  6316.             continue;
  6317.         }

  6319.         if (ngx_strcmp(value[i].data, "down") == 0) {

  6321.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6322.                 goto not_supported;
  6323.             }

  6325.             us->down = 1;

  6327.             continue;
  6328.         }

  6330. #if (NGX_HTTP_UPSTREAM_ZONE)
  6331.         if (ngx_strcmp(value[i].data, "resolve") == 0) {
  6332.             resolve = 1;
  6333.             continue;
  6334.         }

  6336.         if (ngx_strncmp(value[i].data, "service=", 8) == 0) {

  6338.             us->service.len = value[i].len - 8;
  6339.             us->service.data = &value[i].data[8];

  6341.             if (us->service.len == 0) {
  6342.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "service is empty");
  6343.                 return NGX_CONF_ERROR;
  6344.             }

  6346.             continue;
  6347.         }
  6348. #endif

  6350.         goto invalid;
  6351.     }

  6353.     ngx_memzero(&u, sizeof(ngx_url_t));

  6355.     u.url = value[1];
  6356.     u.default_port = 80;

  6358. #if (NGX_HTTP_UPSTREAM_ZONE)
  6359.     if (resolve) {
  6360.         /* resolve at run time */
  6361.         u.no_resolve = 1;
  6362.     }

  6364.     if (us->service.len && !resolve) {
  6365.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6366.                            "service upstream \"%V\" requires "
  6367.                            "\"resolve\" parameter",
  6368.                            &u.url);
  6369.         return NGX_CONF_ERROR;
  6370.     }

  6372. #endif

  6374.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  6375.         if (u.err) {
  6376.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6377.                                "%s in upstream \"%V\"", u.err, &u.url);
  6378.         }

  6380.         return NGX_CONF_ERROR;
  6381.     }

  6383.     us->name = u.url;

  6385. #if (NGX_HTTP_UPSTREAM_ZONE)

  6387.     if (us->service.len && !u.no_port) {
  6388.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6389.                            "service upstream \"%V\" may not have port",
  6390.                            &us->name);

  6392.         return NGX_CONF_ERROR;
  6393.     }

  6395.     if (us->service.len && u.naddrs) {
  6396.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6397.                            "service upstream \"%V\" requires domain name",
  6398.                            &us->name);

  6400.         return NGX_CONF_ERROR;
  6401.     }

  6403.     if (resolve && u.naddrs == 0) {
  6404.         ngx_addr_t  *addr;

  6406.         /* save port */

  6408.         addr = ngx_pcalloc(cf->pool, sizeof(ngx_addr_t));
  6409.         if (addr == NULL) {
  6410.             return NGX_CONF_ERROR;
  6411.         }

  6413.         addr->sockaddr = ngx_palloc(cf->pool, u.socklen);
  6414.         if (addr->sockaddr == NULL) {
  6415.             return NGX_CONF_ERROR;
  6416.         }

  6418.         ngx_memcpy(addr->sockaddr, &u.sockaddr, u.socklen);

  6420.         addr->socklen = u.socklen;

  6422.         us->addrs = addr;
  6423.         us->naddrs = 1;

  6425.         us->host = u.host;

  6427.     } else {
  6428.         us->addrs = u.addrs;
  6429.         us->naddrs = u.naddrs;
  6430.     }

  6432. #else

  6434.     us->addrs = u.addrs;
  6435.     us->naddrs = u.naddrs;

  6437. #endif

  6439.     us->weight = weight;
  6440.     us->max_conns = max_conns;
  6441.     us->max_fails = max_fails;
  6442.     us->fail_timeout = fail_timeout;

  6444.     return NGX_CONF_OK;

  6446. invalid:

  6448.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6449.                        "invalid parameter \"%V\"", &value[i]);

  6451.     return NGX_CONF_ERROR;

  6453. not_supported:

  6455.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6456.                        "balancing method does not support parameter \"%V\"",
  6457.                        &value[i]);

  6459.     return NGX_CONF_ERROR;
  6460. }


  6463. #if (NGX_HTTP_UPSTREAM_ZONE)

  6465. static char *
  6466. ‌ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6467. {
  6468.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6470.     ngx_str_t  *value;

  6472.     if (uscf->resolver) {
  6473.         return "is duplicate";
  6474.     }

  6476.     value = cf->args->elts;

  6478.     uscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  6479.     if (uscf->resolver == NULL) {
  6480.         return NGX_CONF_ERROR;
  6481.     }

  6483.     return NGX_CONF_OK;
  6484. }

  6486. #endif


  6489. ngx_http_upstream_srv_conf_t *
  6490. ‌ngx_http_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
  6491. {
  6492.     ngx_uint_t                      i;
  6493.     ngx_http_upstream_server_t     *us;
  6494.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  6495.     ngx_http_upstream_main_conf_t  *umcf;

  6497.     if (!(flags & NGX_HTTP_UPSTREAM_CREATE)) {

  6499.         if (ngx_parse_url(cf->pool, u) != NGX_OK) {
  6500.             if (u->err) {
  6501.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6502.                                    "%s in upstream \"%V\"", u->err, &u->url);
  6503.             }

  6505.             return NULL;
  6506.         }
  6507.     }

  6509.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

  6511.     uscfp = umcf->upstreams.elts;

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

  6515.         if (uscfp[i]->host.len != u->host.len
  6516.             || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
  6517.                != 0)
  6518.         {
  6519.             continue;
  6520.         }

  6522.         if ((flags & NGX_HTTP_UPSTREAM_CREATE)
  6523.              && (uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE))
  6524.         {
  6525.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6526.                                "duplicate upstream \"%V\"", &u->host);
  6527.             return NULL;
  6528.         }

  6530.         if ((uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE) && !u->no_port) {
  6531.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6532.                                "upstream \"%V\" may not have port %d",
  6533.                                &u->host, u->port);
  6534.             return NULL;
  6535.         }

  6537.         if ((flags & NGX_HTTP_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
  6538.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  6539.                           "upstream \"%V\" may not have port %d in %s:%ui",
  6540.                           &u->host, uscfp[i]->port,
  6541.                           uscfp[i]->file_name, uscfp[i]->line);
  6542.             return NULL;
  6543.         }

  6545.         if (uscfp[i]->port && u->port
  6546.             && uscfp[i]->port != u->port)
  6547.         {
  6548.             continue;
  6549.         }

  6551.         if (flags & NGX_HTTP_UPSTREAM_CREATE) {
  6552.             uscfp[i]->flags = flags;
  6553.             uscfp[i]->port = 0;
  6554.         }

  6556.         return uscfp[i];
  6557.     }

  6559.     uscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
  6560.     if (uscf == NULL) {
  6561.         return NULL;
  6562.     }

  6564.     uscf->flags = flags;
  6565.     uscf->host = u->host;
  6566.     uscf->file_name = cf->conf_file->file.name.data;
  6567.     uscf->line = cf->conf_file->line;
  6568.     uscf->port = u->port;
  6569.     uscf->no_port = u->no_port;
  6570. #if (NGX_HTTP_UPSTREAM_ZONE)
  6571.     uscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  6572. #endif

  6574.     if (u->naddrs == 1 && (u->port || u->family == AF_UNIX)) {
  6575.         uscf->servers = ngx_array_create(cf->pool, 1,
  6576.                                          sizeof(ngx_http_upstream_server_t));
  6577.         if (uscf->servers == NULL) {
  6578.             return NULL;
  6579.         }

  6581.         us = ngx_array_push(uscf->servers);
  6582.         if (us == NULL) {
  6583.             return NULL;
  6584.         }

  6586.         ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6588.         us->addrs = u->addrs;
  6589.         us->naddrs = 1;
  6590.     }

  6592.     uscfp = ngx_array_push(&umcf->upstreams);
  6593.     if (uscfp == NULL) {
  6594.         return NULL;
  6595.     }

  6597.     *uscfp = uscf;

  6599.     return uscf;
  6600. }


  6603. char *
  6604. ‌ngx_http_upstream_bind_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  6605.     void *conf)
  6606. {
  6607.     char  *p = conf;

  6609.     ngx_int_t                           rc;
  6610.     ngx_str_t                          *value;
  6611.     ngx_http_complex_value_t            cv;
  6612.     ngx_http_upstream_local_t         **plocal, *local;
  6613.     ngx_http_compile_complex_value_t    ccv;

  6615.     plocal = (ngx_http_upstream_local_t **) (p + cmd->offset);

  6617.     if (*plocal != NGX_CONF_UNSET_PTR) {
  6618.         return "is duplicate";
  6619.     }

  6621.     value = cf->args->elts;

  6623.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  6624.         *plocal = NULL;
  6625.         return NGX_CONF_OK;
  6626.     }

  6628.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  6630.     ccv.cf = cf;
  6631.     ccv.value = &value[1];
  6632.     ccv.complex_value = &cv;

  6634.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  6635.         return NGX_CONF_ERROR;
  6636.     }

  6638.     local = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_local_t));
  6639.     if (local == NULL) {
  6640.         return NGX_CONF_ERROR;
  6641.     }

  6643.     *plocal = local;

  6645.     if (cv.lengths) {
  6646.         local->value = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  6647.         if (local->value == NULL) {
  6648.             return NGX_CONF_ERROR;
  6649.         }

  6651.         *local->value = cv;

  6653.     } else {
  6654.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  6655.         if (local->addr == NULL) {
  6656.             return NGX_CONF_ERROR;
  6657.         }

  6659.         rc = ngx_parse_addr_port(cf->pool, local->addr, value[1].data,
  6660.                                  value[1].len);

  6662.         switch (rc) {
  6663.         case NGX_OK:
  6664.             local->addr->name = value[1];
  6665.             break;

  6667.         case NGX_DECLINED:
  6668.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6669.                                "invalid address \"%V\"", &value[1]);
  6670.             /* fall through */

  6672.         default:
  6673.             return NGX_CONF_ERROR;
  6674.         }
  6675.     }

  6677.     if (cf->args->nelts > 2) {
  6678.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  6679. #if (NGX_HAVE_TRANSPARENT_PROXY)
  6680.             ngx_core_conf_t  *ccf;

  6682.             ccf = (ngx_core_conf_t *) ngx_get_conf(cf->cycle->conf_ctx,
  6683.                                                    ngx_core_module);

  6685.             ccf->transparent = 1;
  6686.             local->transparent = 1;
  6687. #else
  6688.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6689.                                "transparent proxying is not supported "
  6690.                                "on this platform, ignored");
  6691. #endif
  6692.         } else {
  6693.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6694.                                "invalid parameter \"%V\"", &value[2]);
  6695.             return NGX_CONF_ERROR;
  6696.         }
  6697.     }

  6699.     return NGX_CONF_OK;
  6700. }


  6703. static ngx_int_t
  6704. ‌ngx_http_upstream_set_local(ngx_http_request_t *r, ngx_http_upstream_t *u,
  6705.     ngx_http_upstream_local_t *local)
  6706. {
  6707.     ngx_int_t    rc;
  6708.     ngx_str_t    val;
  6709.     ngx_addr_t  *addr;

  6711.     if (local == NULL) {
  6712.         u->peer.local = NULL;
  6713.         return NGX_OK;
  6714.     }

  6716. #if (NGX_HAVE_TRANSPARENT_PROXY)
  6717.     u->peer.transparent = local->transparent;
  6718. #endif

  6720.     if (local->value == NULL) {
  6721.         u->peer.local = local->addr;
  6722.         return NGX_OK;
  6723.     }

  6725.     if (ngx_http_complex_value(r, local->value, &val) != NGX_OK) {
  6726.         return NGX_ERROR;
  6727.     }

  6729.     if (val.len == 0) {
  6730.         return NGX_OK;
  6731.     }

  6733.     addr = ngx_palloc(r->pool, sizeof(ngx_addr_t));
  6734.     if (addr == NULL) {
  6735.         return NGX_ERROR;
  6736.     }

  6738.     rc = ngx_parse_addr_port(r->pool, addr, val.data, val.len);
  6739.     if (rc == NGX_ERROR) {
  6740.         return NGX_ERROR;
  6741.     }

  6743.     if (rc != NGX_OK) {
  6744.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  6745.                       "invalid local address \"%V\"", &val);
  6746.         return NGX_OK;
  6747.     }

  6749.     addr->name = val;
  6750.     u->peer.local = addr;

  6752.     return NGX_OK;
  6753. }


  6756. char *
  6757. ‌ngx_http_upstream_param_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  6758.     void *conf)
  6759. {
  6760.     char  *p = conf;

  6762.     ngx_str_t                   *value;
  6763.     ngx_array_t                **a;
  6764.     ngx_http_upstream_param_t   *param;

  6766.     a = (ngx_array_t **) (p + cmd->offset);

  6768.     if (*a == NULL) {
  6769.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_param_t));
  6770.         if (*a == NULL) {
  6771.             return NGX_CONF_ERROR;
  6772.         }
  6773.     }

  6775.     param = ngx_array_push(*a);
  6776.     if (param == NULL) {
  6777.         return NGX_CONF_ERROR;
  6778.     }

  6780.     value = cf->args->elts;

  6782.     param->key = value[1];
  6783.     param->value = value[2];
  6784.     param->skip_empty = 0;

  6786.     if (cf->args->nelts == 4) {
  6787.         if (ngx_strcmp(value[3].data, "if_not_empty") != 0) {
  6788.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6789.                                "invalid parameter \"%V\"", &value[3]);
  6790.             return NGX_CONF_ERROR;
  6791.         }

  6793.         param->skip_empty = 1;
  6794.     }

  6796.     return NGX_CONF_OK;
  6797. }


  6800. ngx_int_t
  6801. ‌ngx_http_upstream_hide_headers_hash(ngx_conf_t *cf,
  6802.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev,
  6803.     ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
  6804. {
  6805.     ngx_str_t       *h;
  6806.     ngx_uint_t       i, j;
  6807.     ngx_array_t      hide_headers;
  6808.     ngx_hash_key_t  *hk;

  6810.     if (conf->hide_headers == NGX_CONF_UNSET_PTR
  6811.         && conf->pass_headers == NGX_CONF_UNSET_PTR)
  6812.     {
  6813.         conf->hide_headers = prev->hide_headers;
  6814.         conf->pass_headers = prev->pass_headers;

  6816.         conf->hide_headers_hash = prev->hide_headers_hash;

  6818.         if (conf->hide_headers_hash.buckets) {
  6819.             return NGX_OK;
  6820.         }

  6822.     } else {
  6823.         if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
  6824.             conf->hide_headers = prev->hide_headers;
  6825.         }

  6827.         if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
  6828.             conf->pass_headers = prev->pass_headers;
  6829.         }
  6830.     }

  6832.     if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  6833.         != NGX_OK)
  6834.     {
  6835.         return NGX_ERROR;
  6836.     }

  6838.     for (h = default_hide_headers; h->len; h++) {
  6839.         hk = ngx_array_push(&hide_headers);
  6840.         if (hk == NULL) {
  6841.             return NGX_ERROR;
  6842.         }

  6844.         hk->key = *h;
  6845.         hk->key_hash = ngx_hash_key_lc(h->data, h->len);
  6846.         hk->value = (void *) 1;
  6847.     }

  6849.     if (conf->hide_headers != NGX_CONF_UNSET_PTR) {

  6851.         h = conf->hide_headers->elts;

  6853.         for (i = 0; i < conf->hide_headers->nelts; i++) {

  6855.             hk = hide_headers.elts;

  6857.             for (j = 0; j < hide_headers.nelts; j++) {
  6858.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  6859.                     goto exist;
  6860.                 }
  6861.             }

  6863.             hk = ngx_array_push(&hide_headers);
  6864.             if (hk == NULL) {
  6865.                 return NGX_ERROR;
  6866.             }

  6868.             hk->key = h[i];
  6869.             hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
  6870.             hk->value = (void *) 1;

  6872.         exist:

  6874.             continue;
  6875.         }
  6876.     }

  6878.     if (conf->pass_headers != NGX_CONF_UNSET_PTR) {

  6880.         h = conf->pass_headers->elts;
  6881.         hk = hide_headers.elts;

  6883.         for (i = 0; i < conf->pass_headers->nelts; i++) {
  6884.             for (j = 0; j < hide_headers.nelts; j++) {

  6886.                 if (hk[j].key.data == NULL) {
  6887.                     continue;
  6888.                 }

  6890.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  6891.                     hk[j].key.data = NULL;
  6892.                     break;
  6893.                 }
  6894.             }
  6895.         }
  6896.     }

  6898.     hash->hash = &conf->hide_headers_hash;
  6899.     hash->key = ngx_hash_key_lc;
  6900.     hash->pool = cf->pool;
  6901.     hash->temp_pool = NULL;

  6903.     if (ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts) != NGX_OK) {
  6904.         return NGX_ERROR;
  6905.     }

  6907.     /*
  6908.      * special handling to preserve conf->hide_headers_hash
  6909.      * in the "http" section to inherit it to all servers
  6910.      */

  6912.     if (prev->hide_headers_hash.buckets == NULL
  6913.         && conf->hide_headers == prev->hide_headers
  6914.         && conf->pass_headers == prev->pass_headers)
  6915.     {
  6916.         prev->hide_headers_hash = conf->hide_headers_hash;
  6917.     }

  6919.     return NGX_OK;
  6920. }


  6923. static void *
  6924. ‌ngx_http_upstream_create_main_conf(ngx_conf_t *cf)
  6925. {
  6926.     ngx_http_upstream_main_conf_t  *umcf;

  6928.     umcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_main_conf_t));
  6929.     if (umcf == NULL) {
  6930.         return NULL;
  6931.     }

  6933.     if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
  6934.                        sizeof(ngx_http_upstream_srv_conf_t *))
  6935.         != NGX_OK)
  6936.     {
  6937.         return NULL;
  6938.     }

  6940.     return umcf;
  6941. }


  6944. static char *
  6945. ‌ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
  6946. {
  6947.     ngx_http_upstream_main_conf_t  *umcf = conf;

  6949.     ngx_uint_t                      i;
  6950.     ngx_array_t                     headers_in;
  6951.     ngx_hash_key_t                 *hk;
  6952.     ngx_hash_init_t                 hash;
  6953.     ngx_http_upstream_init_pt       init;
  6954.     ngx_http_upstream_header_t     *header;
  6955.     ngx_http_upstream_srv_conf_t  **uscfp;

  6957.     uscfp = umcf->upstreams.elts;

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

  6961.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:
  6962.                                             ngx_http_upstream_init_round_robin;

  6964.         if (init(cf, uscfp[i]) != NGX_OK) {
  6965.             return NGX_CONF_ERROR;
  6966.         }
  6967.     }


  6970.     /* upstream_headers_in_hash */

  6972.     if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
  6973.         != NGX_OK)
  6974.     {
  6975.         return NGX_CONF_ERROR;
  6976.     }

  6978.     for (header = ngx_http_upstream_headers_in; header->name.len; header++) {
  6979.         hk = ngx_array_push(&headers_in);
  6980.         if (hk == NULL) {
  6981.             return NGX_CONF_ERROR;
  6982.         }

  6984.         hk->key = header->name;
  6985.         hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
  6986.         hk->value = header;
  6987.     }

  6989.     hash.hash = &umcf->headers_in_hash;
  6990.     hash.key = ngx_hash_key_lc;
  6991.     hash.max_size = 512;
  6992.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  6993.     hash.name = "upstream_headers_in_hash";
  6994.     hash.pool = cf->pool;
  6995.     hash.temp_pool = NULL;

  6997.     if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
  6998.         return NGX_CONF_ERROR;
  6999.     }

  7001.     return NGX_CONF_OK;
  7002. }

One Level Up Top Level