One Level Up Top Level

src/http/ngx_http_upstream.c - nginx

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_process_early_hints(ngx_http_request_t *r,
  52.     ngx_http_upstream_t *u);
  53. static void ngx_http_upstream_early_hints_writer(ngx_http_request_t *r);
  54. static ngx_int_t ngx_http_upstream_test_next(ngx_http_request_t *r,
  55.     ngx_http_upstream_t *u);
  56. static ngx_int_t ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  57.     ngx_http_upstream_t *u);
  58. static ngx_int_t ngx_http_upstream_test_connect(ngx_connection_t *c);
  59. static ngx_int_t ngx_http_upstream_process_headers(ngx_http_request_t *r,
  60.     ngx_http_upstream_t *u);
  61. static ngx_int_t ngx_http_upstream_process_trailers(ngx_http_request_t *r,
  62.     ngx_http_upstream_t *u);
  63. static void ngx_http_upstream_send_response(ngx_http_request_t *r,
  64.     ngx_http_upstream_t *u);
  65. static void ngx_http_upstream_upgrade(ngx_http_request_t *r,
  66.     ngx_http_upstream_t *u);
  67. static void ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r);
  68. static void ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r);
  69. static void ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  70.     ngx_http_upstream_t *u);
  71. static void ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  72.     ngx_http_upstream_t *u);
  73. static void ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  74.     ngx_uint_t from_upstream, ngx_uint_t do_write);
  75. static void
  76.     ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r);
  77. static void
  78.     ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  79.     ngx_http_upstream_t *u);
  80. static void
  81.     ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  82.     ngx_uint_t do_write);
  83. #if (NGX_THREADS)
  84. static ngx_int_t ngx_http_upstream_thread_handler(ngx_thread_task_t *task,
  85.     ngx_file_t *file);
  86. static void ngx_http_upstream_thread_event_handler(ngx_event_t *ev);
  87. #endif
  88. static ngx_int_t ngx_http_upstream_output_filter(void *data,
  89.     ngx_chain_t *chain);
  90. static void ngx_http_upstream_process_downstream(ngx_http_request_t *r);
  91. static void ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  92.     ngx_http_upstream_t *u);
  93. static void ngx_http_upstream_process_request(ngx_http_request_t *r,
  94.     ngx_http_upstream_t *u);
  95. static void ngx_http_upstream_store(ngx_http_request_t *r,
  96.     ngx_http_upstream_t *u);
  97. static void ngx_http_upstream_dummy_handler(ngx_http_request_t *r,
  98.     ngx_http_upstream_t *u);
  99. static void ngx_http_upstream_next(ngx_http_request_t *r,
  100.     ngx_http_upstream_t *u, ngx_uint_t ft_type);
  101. static void ngx_http_upstream_cleanup(void *data);
  102. static void ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  103.     ngx_http_upstream_t *u, ngx_int_t rc);

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

  160. static ngx_int_t ngx_http_upstream_add_variables(ngx_conf_t *cf);
  161. static ngx_int_t ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  162.     ngx_http_variable_value_t *v, uintptr_t data);
  163. static ngx_int_t ngx_http_upstream_status_variable(ngx_http_request_t *r,
  164.     ngx_http_variable_value_t *v, uintptr_t data);
  165. static ngx_int_t ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  166.     ngx_http_variable_value_t *v, uintptr_t data);
  167. static ngx_int_t ngx_http_upstream_response_length_variable(
  168.     ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
  169. static ngx_int_t ngx_http_upstream_header_variable(ngx_http_request_t *r,
  170.     ngx_http_variable_value_t *v, uintptr_t data);
  171. static ngx_int_t ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  172.     ngx_http_variable_value_t *v, uintptr_t data);
  173. static ngx_int_t ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  174.     ngx_http_variable_value_t *v, uintptr_t data);

  176. static char *ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy);
  177. static char *ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd,
  178.     void *conf);
  179. #if (NGX_HTTP_UPSTREAM_ZONE)
  180. static char *ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  181.     void *conf);
  182. #endif

  184. static ngx_int_t ngx_http_upstream_set_local(ngx_http_request_t *r,
  185.   ngx_http_upstream_t *u, ngx_http_upstream_local_t *local);

  187. static void *ngx_http_upstream_create_main_conf(ngx_conf_t *cf);
  188. static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf);

  190. #if (NGX_HTTP_SSL)
  191. static void ngx_http_upstream_ssl_init_connection(ngx_http_request_t *,
  192.     ngx_http_upstream_t *u, ngx_connection_t *c);
  193. static void ngx_http_upstream_ssl_handshake_handler(ngx_connection_t *c);
  194. static void ngx_http_upstream_ssl_handshake(ngx_http_request_t *,
  195.     ngx_http_upstream_t *u, ngx_connection_t *c);
  196. static void ngx_http_upstream_ssl_save_session(ngx_connection_t *c);
  197. static ngx_int_t ngx_http_upstream_ssl_name(ngx_http_request_t *r,
  198.     ngx_http_upstream_t *u, ngx_connection_t *c);
  199. static ngx_int_t ngx_http_upstream_ssl_certificate(ngx_http_request_t *r,
  200.     ngx_http_upstream_t *u, ngx_connection_t *c);
  201. #endif


  204. ‌static ngx_http_upstream_header_t  ngx_http_upstream_headers_in[] = {

  206.     { ngx_string("Status"),
  207.                  ngx_http_upstream_process_header_line,
  208.                  offsetof(ngx_http_upstream_headers_in_t, status),
  209.                  ngx_http_upstream_copy_header_line, 0, 0 },

  211.     { ngx_string("Content-Type"),
  212.                  ngx_http_upstream_process_header_line,
  213.                  offsetof(ngx_http_upstream_headers_in_t, content_type),
  214.                  ngx_http_upstream_copy_content_type, 0, 1 },

  216.     { ngx_string("Content-Length"),
  217.                  ngx_http_upstream_process_content_length, 0,
  218.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  220.     { ngx_string("Date"),
  221.                  ngx_http_upstream_process_header_line,
  222.                  offsetof(ngx_http_upstream_headers_in_t, date),
  223.                  ngx_http_upstream_copy_header_line,
  224.                  offsetof(ngx_http_headers_out_t, date), 0 },

  226.     { ngx_string("Last-Modified"),
  227.                  ngx_http_upstream_process_last_modified, 0,
  228.                  ngx_http_upstream_copy_last_modified, 0, 0 },

  230.     { ngx_string("ETag"),
  231.                  ngx_http_upstream_process_header_line,
  232.                  offsetof(ngx_http_upstream_headers_in_t, etag),
  233.                  ngx_http_upstream_copy_header_line,
  234.                  offsetof(ngx_http_headers_out_t, etag), 0 },

  236.     { ngx_string("Server"),
  237.                  ngx_http_upstream_process_header_line,
  238.                  offsetof(ngx_http_upstream_headers_in_t, server),
  239.                  ngx_http_upstream_copy_header_line,
  240.                  offsetof(ngx_http_headers_out_t, server), 0 },

  242.     { ngx_string("WWW-Authenticate"),
  243.                  ngx_http_upstream_process_multi_header_lines,
  244.                  offsetof(ngx_http_upstream_headers_in_t, www_authenticate),
  245.                  ngx_http_upstream_copy_header_line, 0, 0 },

  247.     { ngx_string("Location"),
  248.                  ngx_http_upstream_process_header_line,
  249.                  offsetof(ngx_http_upstream_headers_in_t, location),
  250.                  ngx_http_upstream_rewrite_location, 0, 0 },

  252.     { ngx_string("Refresh"),
  253.                  ngx_http_upstream_process_header_line,
  254.                  offsetof(ngx_http_upstream_headers_in_t, refresh),
  255.                  ngx_http_upstream_rewrite_refresh, 0, 0 },

  257.     { ngx_string("Set-Cookie"),
  258.                  ngx_http_upstream_process_set_cookie,
  259.                  offsetof(ngx_http_upstream_headers_in_t, set_cookie),
  260.                  ngx_http_upstream_rewrite_set_cookie, 0, 1 },

  262.     { ngx_string("Content-Disposition"),
  263.                  ngx_http_upstream_ignore_header_line, 0,
  264.                  ngx_http_upstream_copy_header_line, 0, 1 },

  266.     { ngx_string("Cache-Control"),
  267.                  ngx_http_upstream_process_cache_control, 0,
  268.                  ngx_http_upstream_copy_multi_header_lines,
  269.                  offsetof(ngx_http_headers_out_t, cache_control), 1 },

  271.     { ngx_string("Expires"),
  272.                  ngx_http_upstream_process_expires, 0,
  273.                  ngx_http_upstream_copy_header_line,
  274.                  offsetof(ngx_http_headers_out_t, expires), 1 },

  276.     { ngx_string("Accept-Ranges"),
  277.                  ngx_http_upstream_ignore_header_line, 0,
  278.                  ngx_http_upstream_copy_allow_ranges,
  279.                  offsetof(ngx_http_headers_out_t, accept_ranges), 1 },

  281.     { ngx_string("Content-Range"),
  282.                  ngx_http_upstream_ignore_header_line, 0,
  283.                  ngx_http_upstream_copy_header_line,
  284.                  offsetof(ngx_http_headers_out_t, content_range), 0 },

  286.     { ngx_string("Connection"),
  287.                  ngx_http_upstream_process_connection, 0,
  288.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  290.     { ngx_string("Keep-Alive"),
  291.                  ngx_http_upstream_ignore_header_line, 0,
  292.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  294.     { ngx_string("Vary"),
  295.                  ngx_http_upstream_process_vary, 0,
  296.                  ngx_http_upstream_copy_header_line, 0, 0 },

  298.     { ngx_string("Link"),
  299.                  ngx_http_upstream_ignore_header_line, 0,
  300.                  ngx_http_upstream_copy_multi_header_lines,
  301.                  offsetof(ngx_http_headers_out_t, link), 0 },

  303.     { ngx_string("X-Accel-Expires"),
  304.                  ngx_http_upstream_process_accel_expires, 0,
  305.                  ngx_http_upstream_copy_header_line, 0, 0 },

  307.     { ngx_string("X-Accel-Redirect"),
  308.                  ngx_http_upstream_process_header_line,
  309.                  offsetof(ngx_http_upstream_headers_in_t, x_accel_redirect),
  310.                  ngx_http_upstream_copy_header_line, 0, 0 },

  312.     { ngx_string("X-Accel-Limit-Rate"),
  313.                  ngx_http_upstream_process_limit_rate, 0,
  314.                  ngx_http_upstream_copy_header_line, 0, 0 },

  316.     { ngx_string("X-Accel-Buffering"),
  317.                  ngx_http_upstream_process_buffering, 0,
  318.                  ngx_http_upstream_copy_header_line, 0, 0 },

  320.     { ngx_string("X-Accel-Charset"),
  321.                  ngx_http_upstream_process_charset, 0,
  322.                  ngx_http_upstream_copy_header_line, 0, 0 },

  324.     { ngx_string("Transfer-Encoding"),
  325.                  ngx_http_upstream_process_transfer_encoding, 0,
  326.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  328.     { ngx_string("Content-Encoding"),
  329.                  ngx_http_upstream_ignore_header_line, 0,
  330.                  ngx_http_upstream_copy_header_line,
  331.                  offsetof(ngx_http_headers_out_t, content_encoding), 0 },

  333.     { ngx_null_string, NULL, 0, NULL, 0, 0 }
  334. };


  337. ‌static ngx_command_t  ngx_http_upstream_commands[] = {

  339.     { ngx_string("upstream"),
  340.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
  341.       ngx_http_upstream,
  342.       0,
  343.       0,
  344.       NULL },

  346.     { ngx_string("server"),
  347.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  348.       ngx_http_upstream_server,
  349.       NGX_HTTP_SRV_CONF_OFFSET,
  350.       0,
  351.       NULL },

  353. #if (NGX_HTTP_UPSTREAM_ZONE)

  355.     { ngx_string("resolver"),
  356.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  357.       ngx_http_upstream_resolver,
  358.       NGX_HTTP_SRV_CONF_OFFSET,
  359.       0,
  360.       NULL },

  362.     { ngx_string("resolver_timeout"),
  363.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  364.       ngx_conf_set_msec_slot,
  365.       NGX_HTTP_SRV_CONF_OFFSET,
  366.       offsetof(ngx_http_upstream_srv_conf_t, resolver_timeout),
  367.       NULL },

  369. #endif

  371.       ngx_null_command
  372. };


  375. ‌static ngx_http_module_t  ngx_http_upstream_module_ctx = {
  376.     ngx_http_upstream_add_variables,       /* preconfiguration */
  377.     NULL,                                  /* postconfiguration */

  379.     ngx_http_upstream_create_main_conf,    /* create main configuration */
  380.     ngx_http_upstream_init_main_conf,      /* init main configuration */

  382.     NULL,                                  /* create server configuration */
  383.     NULL,                                  /* merge server configuration */

  385.     NULL,                                  /* create location configuration */
  386.     NULL                                   /* merge location configuration */
  387. };


  390. ‌ngx_module_t  ngx_http_upstream_module = {
  391.     NGX_MODULE_V1,
  392.     &ngx_http_upstream_module_ctx,         /* module context */
  393.     ngx_http_upstream_commands,            /* module directives */
  394.     NGX_HTTP_MODULE,                       /* module type */
  395.     NULL,                                  /* init master */
  396.     NULL,                                  /* init module */
  397.     NULL,                                  /* init process */
  398.     NULL,                                  /* init thread */
  399.     NULL,                                  /* exit thread */
  400.     NULL,                                  /* exit process */
  401.     NULL,                                  /* exit master */
  402.     NGX_MODULE_V1_PADDING
  403. };


  406. ‌static ngx_http_variable_t  ngx_http_upstream_vars[] = {

  408.     { ngx_string("upstream_addr"), NULL,
  409.       ngx_http_upstream_addr_variable, 0,
  410.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  412.     { ngx_string("upstream_status"), NULL,
  413.       ngx_http_upstream_status_variable, 0,
  414.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  416.     { ngx_string("upstream_connect_time"), NULL,
  417.       ngx_http_upstream_response_time_variable, 2,
  418.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  420.     { ngx_string("upstream_header_time"), NULL,
  421.       ngx_http_upstream_response_time_variable, 1,
  422.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  424.     { ngx_string("upstream_response_time"), NULL,
  425.       ngx_http_upstream_response_time_variable, 0,
  426.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  428.     { ngx_string("upstream_response_length"), NULL,
  429.       ngx_http_upstream_response_length_variable, 0,
  430.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  432.     { ngx_string("upstream_bytes_received"), NULL,
  433.       ngx_http_upstream_response_length_variable, 1,
  434.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  436.     { ngx_string("upstream_bytes_sent"), NULL,
  437.       ngx_http_upstream_response_length_variable, 2,
  438.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  440. #if (NGX_HTTP_CACHE)

  442.     { ngx_string("upstream_cache_status"), NULL,
  443.       ngx_http_upstream_cache_status, 0,
  444.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  446.     { ngx_string("upstream_cache_last_modified"), NULL,
  447.       ngx_http_upstream_cache_last_modified, 0,
  448.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  450.     { ngx_string("upstream_cache_etag"), NULL,
  451.       ngx_http_upstream_cache_etag, 0,
  452.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  454. #endif

  456.     { ngx_string("upstream_http_"), NULL, ngx_http_upstream_header_variable,
  457.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  459.     { ngx_string("upstream_trailer_"), NULL, ngx_http_upstream_trailer_variable,
  460.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  462.     { ngx_string("upstream_cookie_"), NULL, ngx_http_upstream_cookie_variable,
  463.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  465.       ngx_http_null_variable
  466. };


  469. ‌static ngx_http_upstream_next_t  ngx_http_upstream_next_errors[] = {
  470.     { 500, NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  471.     { 502, NGX_HTTP_UPSTREAM_FT_HTTP_502 },
  472.     { 503, NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  473.     { 504, NGX_HTTP_UPSTREAM_FT_HTTP_504 },
  474.     { 403, NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  475.     { 404, NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  476.     { 429, NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  477.     { 0, 0 }
  478. };


  481. ‌ngx_conf_bitmask_t  ngx_http_upstream_cache_method_mask[] = {
  482.     { ngx_string("GET"), NGX_HTTP_GET },
  483.     { ngx_string("HEAD"), NGX_HTTP_HEAD },
  484.     { ngx_string("POST"), NGX_HTTP_POST },
  485.     { ngx_null_string, 0 }
  486. };


  489. ‌ngx_conf_bitmask_t  ngx_http_upstream_ignore_headers_masks[] = {
  490.     { ngx_string("X-Accel-Redirect"), NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT },
  491.     { ngx_string("X-Accel-Expires"), NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES },
  492.     { ngx_string("X-Accel-Limit-Rate"), NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE },
  493.     { ngx_string("X-Accel-Buffering"), NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING },
  494.     { ngx_string("X-Accel-Charset"), NGX_HTTP_UPSTREAM_IGN_XA_CHARSET },
  495.     { ngx_string("Expires"), NGX_HTTP_UPSTREAM_IGN_EXPIRES },
  496.     { ngx_string("Cache-Control"), NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL },
  497.     { ngx_string("Set-Cookie"), NGX_HTTP_UPSTREAM_IGN_SET_COOKIE },
  498.     { ngx_string("Vary"), NGX_HTTP_UPSTREAM_IGN_VARY },
  499.     { ngx_null_string, 0 }
  500. };


  503. ngx_int_t
  504. ‌ngx_http_upstream_create(ngx_http_request_t *r)
  505. {
  506.     ngx_http_upstream_t  *u;

  508.     u = r->upstream;

  510.     if (u && u->cleanup) {
  511.         r->main->count++;
  512.         ngx_http_upstream_cleanup(r);
  513.     }

  515.     u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
  516.     if (u == NULL) {
  517.         return NGX_ERROR;
  518.     }

  520.     r->upstream = u;

  522.     u->peer.log = r->connection->log;
  523.     u->peer.log_error = NGX_ERROR_ERR;

  525. #if (NGX_HTTP_CACHE)
  526.     r->cache = NULL;
  527. #endif

  529.     u->headers_in.content_length_n = -1;
  530.     u->headers_in.last_modified_time = -1;

  532.     return NGX_OK;
  533. }


  536. void
  537. ‌ngx_http_upstream_init(ngx_http_request_t *r)
  538. {
  539.     ngx_connection_t     *c;

  541.     c = r->connection;

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

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

  553. #if (NGX_HTTP_V3)
  554.     if (c->quic) {
  555.         ngx_http_upstream_init_request(r);
  556.         return;
  557.     }
  558. #endif

  560.     if (c->read->timer_set) {
  561.         ngx_del_timer(c->read);
  562.     }

  564.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  566.         if (!c->write->active) {
  567.             if (ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT)
  568.                 == NGX_ERROR)
  569.             {
  570.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  571.                 return;
  572.             }
  573.         }
  574.     }

  576.     ngx_http_upstream_init_request(r);
  577. }


  580. static void
  581. ‌ngx_http_upstream_init_request(ngx_http_request_t *r)
  582. {
  583.     ngx_str_t                      *host;
  584.     ngx_uint_t                      i;
  585.     ngx_resolver_ctx_t             *ctx, temp;
  586.     ngx_http_cleanup_t             *cln;
  587.     ngx_http_upstream_t            *u;
  588.     ngx_http_core_loc_conf_t       *clcf;
  589.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  590.     ngx_http_upstream_main_conf_t  *umcf;

  592.     if (r->aio) {
  593.         return;
  594.     }

  596.     u = r->upstream;

  598. #if (NGX_HTTP_CACHE)

  600.     if (u->conf->cache) {
  601.         ngx_int_t  rc;

  603.         rc = ngx_http_upstream_cache(r, u);

  605.         if (rc == NGX_BUSY) {
  606.             r->write_event_handler = ngx_http_upstream_init_request;
  607.             return;
  608.         }

  610.         r->write_event_handler = ngx_http_request_empty_handler;

  612.         if (rc == NGX_ERROR) {
  613.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  614.             return;
  615.         }

  617.         if (rc == NGX_OK) {
  618.             rc = ngx_http_upstream_cache_send(r, u);

  620.             if (rc == NGX_DONE) {
  621.                 return;
  622.             }

  624.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  625.                 rc = NGX_DECLINED;
  626.                 r->cached = 0;
  627.                 u->buffer.start = NULL;
  628.                 u->cache_status = NGX_HTTP_CACHE_MISS;
  629.                 u->request_sent = 1;
  630.             }
  631.         }

  633.         if (rc != NGX_DECLINED) {
  634.             ngx_http_finalize_request(r, rc);
  635.             return;
  636.         }
  637.     }

  639. #endif

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

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

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

  648.         } else {
  649.             if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  650.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  651.                 return;
  652.             }
  653.         }

  655.         r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;
  656.         r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
  657.     }

  659.     if (r->request_body) {
  660.         u->request_bufs = r->request_body->bufs;
  661.     }

  663.     if (u->create_request(r) != NGX_OK) {
  664.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  665.         return;
  666.     }

  668.     if (ngx_http_upstream_set_local(r, u, u->conf->local) != NGX_OK) {
  669.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  670.         return;
  671.     }

  673.     if (u->conf->socket_keepalive) {
  674.         u->peer.so_keepalive = 1;
  675.     }

  677.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  679.     u->output.alignment = clcf->directio_alignment;
  680.     u->output.pool = r->pool;
  681.     u->output.bufs.num = 1;
  682.     u->output.bufs.size = clcf->client_body_buffer_size;

  684.     if (u->output.output_filter == NULL) {
  685.         u->output.output_filter = ngx_chain_writer;
  686.         u->output.filter_ctx = &u->writer;
  687.     }

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

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

  693.         r->upstream_states = ngx_array_create(r->pool, 1,
  694.                                             sizeof(ngx_http_upstream_state_t));
  695.         if (r->upstream_states == NULL) {
  696.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  697.             return;
  698.         }

  700.     } else {

  702.         u->state = ngx_array_push(r->upstream_states);
  703.         if (u->state == NULL) {
  704.             ngx_http_upstream_finalize_request(r, u,
  705.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  706.             return;
  707.         }

  709.         ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
  710.     }

  712.     cln = ngx_http_cleanup_add(r, 0);
  713.     if (cln == NULL) {
  714.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  715.         return;
  716.     }

  718.     cln->handler = ngx_http_upstream_cleanup;
  719.     cln->data = r;
  720.     u->cleanup = &cln->handler;

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

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

  726.     } else {

  728. #if (NGX_HTTP_SSL)
  729.         u->ssl_name = u->resolved->host;
  730. #endif

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

  734.         umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  736.         uscfp = umcf->upstreams.elts;

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

  740.             uscf = uscfp[i];

  742.             if (uscf->host.len == host->len
  743.                 && ((uscf->port == 0 && u->resolved->no_port)
  744.                      || uscf->port == u->resolved->port)
  745.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  746.             {
  747.                 goto found;
  748.             }
  749.         }

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

  753.             if (u->resolved->port == 0
  754.                 && u->resolved->sockaddr->sa_family != AF_UNIX)
  755.             {
  756.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  757.                               "no port in upstream \"%V\"", host);
  758.                 ngx_http_upstream_finalize_request(r, u,
  759.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  760.                 return;
  761.             }

  763.             if (ngx_http_upstream_create_round_robin_peer(r, u->resolved)
  764.                 != NGX_OK)
  765.             {
  766.                 ngx_http_upstream_finalize_request(r, u,
  767.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  768.                 return;
  769.             }

  771.             ngx_http_upstream_connect(r, u);

  773.             return;
  774.         }

  776.         if (u->resolved->port == 0) {
  777.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  778.                           "no port in upstream \"%V\"", host);
  779.             ngx_http_upstream_finalize_request(r, u,
  780.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  781.             return;
  782.         }

  784.         temp.name = *host;

  786.         ctx = ngx_resolve_start(clcf->resolver, &temp);
  787.         if (ctx == NULL) {
  788.             ngx_http_upstream_finalize_request(r, u,
  789.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  790.             return;
  791.         }

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

  797.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  798.             return;
  799.         }

  801.         ctx->name = *host;
  802.         ctx->handler = ngx_http_upstream_resolve_handler;
  803.         ctx->data = r;
  804.         ctx->timeout = clcf->resolver_timeout;

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

  808.         if (ngx_resolve_name(ctx) != NGX_OK) {
  809.             u->resolved->ctx = NULL;
  810.             ngx_http_upstream_finalize_request(r, u,
  811.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  812.             return;
  813.         }

  815.         return;
  816.     }

  818. found:

  820.     if (uscf == NULL) {
  821.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  822.                       "no upstream configuration");
  823.         ngx_http_upstream_finalize_request(r, u,
  824.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  825.         return;
  826.     }

  828.     u->upstream = uscf;

  830. #if (NGX_HTTP_SSL)
  831.     u->ssl_name = uscf->host;
  832. #endif

  834.     if (uscf->peer.init(r, uscf) != NGX_OK) {
  835.         ngx_http_upstream_finalize_request(r, u,
  836.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  837.         return;
  838.     }

  840.     u->peer.start_time = ngx_current_msec;

  842.     if (u->conf->next_upstream_tries
  843.         && u->peer.tries > u->conf->next_upstream_tries)
  844.     {
  845.         u->peer.tries = u->conf->next_upstream_tries;
  846.     }

  848.     ngx_http_upstream_connect(r, u);
  849. }


  852. #if (NGX_HTTP_CACHE)

  854. static ngx_int_t
  855. ‌ngx_http_upstream_cache(ngx_http_request_t *r, ngx_http_upstream_t *u)
  856. {
  857.     ngx_int_t               rc;
  858.     ngx_http_cache_t       *c;
  859.     ngx_http_file_cache_t  *cache;

  861.     c = r->cache;

  863.     if (c == NULL) {

  865.         if (!(r->method & u->conf->cache_methods)) {
  866.             return NGX_DECLINED;
  867.         }

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

  871.         if (rc != NGX_OK) {
  872.             return rc;
  873.         }

  875.         if (r->method == NGX_HTTP_HEAD && u->conf->cache_convert_head) {
  876.             u->method = ngx_http_core_get_method;
  877.         }

  879.         if (ngx_http_file_cache_new(r) != NGX_OK) {
  880.             return NGX_ERROR;
  881.         }

  883.         if (u->create_key(r) != NGX_OK) {
  884.             return NGX_ERROR;
  885.         }

  887.         /* TODO: add keys */

  889.         ngx_http_file_cache_create_key(r);

  891.         if (r->cache->header_start + 256 > u->conf->buffer_size) {
  892.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  893.                           "%V_buffer_size %uz is not enough for cache key, "
  894.                           "it should be increased to at least %uz",
  895.                           &u->conf->module, u->conf->buffer_size,
  896.                           ngx_align(r->cache->header_start + 256, 1024));

  898.             r->cache = NULL;
  899.             return NGX_DECLINED;
  900.         }

  902.         u->cacheable = 1;

  904.         c = r->cache;

  906.         c->body_start = u->conf->buffer_size;
  907.         c->min_uses = u->conf->cache_min_uses;
  908.         c->file_cache = cache;

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

  912.         case NGX_ERROR:
  913.             return NGX_ERROR;

  915.         case NGX_DECLINED:
  916.             u->cache_status = NGX_HTTP_CACHE_BYPASS;
  917.             return NGX_DECLINED;

  919.         default: /* NGX_OK */
  920.             break;
  921.         }

  923.         c->lock = u->conf->cache_lock;
  924.         c->lock_timeout = u->conf->cache_lock_timeout;
  925.         c->lock_age = u->conf->cache_lock_age;

  927.         u->cache_status = NGX_HTTP_CACHE_MISS;
  928.     }

  930.     rc = ngx_http_file_cache_open(r);

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

  935.     switch (rc) {

  937.     case NGX_HTTP_CACHE_STALE:

  939.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  940.              || c->stale_updating) && !r->background
  941.             && u->conf->cache_background_update)
  942.         {
  943.             if (ngx_http_upstream_cache_background_update(r, u) == NGX_OK) {
  944.                 r->cache->background = 1;
  945.                 u->cache_status = rc;
  946.                 rc = NGX_OK;

  948.             } else {
  949.                 rc = NGX_ERROR;
  950.             }
  951.         }

  953.         break;

  955.     case NGX_HTTP_CACHE_UPDATING:

  957.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  958.              || c->stale_updating) && !r->background)
  959.         {
  960.             u->cache_status = rc;
  961.             rc = NGX_OK;

  963.         } else {
  964.             rc = NGX_HTTP_CACHE_STALE;
  965.         }

  967.         break;

  969.     case NGX_OK:
  970.         u->cache_status = NGX_HTTP_CACHE_HIT;
  971.     }

  973.     switch (rc) {

  975.     case NGX_OK:

  977.         return NGX_OK;

  979.     case NGX_HTTP_CACHE_STALE:

  981.         c->valid_sec = 0;
  982.         c->updating_sec = 0;
  983.         c->error_sec = 0;

  985.         u->buffer.start = NULL;
  986.         u->cache_status = NGX_HTTP_CACHE_EXPIRED;

  988.         break;

  990.     case NGX_DECLINED:

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

  995.         } else {
  996.             u->buffer.pos = u->buffer.start + c->header_start;
  997.             u->buffer.last = u->buffer.pos;
  998.         }

  1000.         break;

  1002.     case NGX_HTTP_CACHE_SCARCE:

  1004.         u->cacheable = 0;

  1006.         break;

  1008.     case NGX_AGAIN:

  1010.         return NGX_BUSY;

  1012.     case NGX_ERROR:

  1014.         return NGX_ERROR;

  1016.     default:

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

  1020.         u->cache_status = NGX_HTTP_CACHE_HIT;

  1022.         return rc;
  1023.     }

  1025.     if (ngx_http_upstream_cache_check_range(r, u) == NGX_DECLINED) {
  1026.         u->cacheable = 0;
  1027.     }

  1029.     r->cached = 0;

  1031.     return NGX_DECLINED;
  1032. }


  1035. static ngx_int_t
  1036. ‌ngx_http_upstream_cache_get(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1037.     ngx_http_file_cache_t **cache)
  1038. {
  1039.     ngx_str_t               *name, val;
  1040.     ngx_uint_t               i;
  1041.     ngx_http_file_cache_t  **caches;

  1043.     if (u->conf->cache_zone) {
  1044.         *cache = u->conf->cache_zone->data;
  1045.         return NGX_OK;
  1046.     }

  1048.     if (ngx_http_complex_value(r, u->conf->cache_value, &val) != NGX_OK) {
  1049.         return NGX_ERROR;
  1050.     }

  1052.     if (val.len == 0
  1053.         || (val.len == 3 && ngx_strncmp(val.data, "off", 3) == 0))
  1054.     {
  1055.         return NGX_DECLINED;
  1056.     }

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

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

  1063.         if (name->len == val.len
  1064.             && ngx_strncmp(name->data, val.data, val.len) == 0)
  1065.         {
  1066.             *cache = caches[i];
  1067.             return NGX_OK;
  1068.         }
  1069.     }

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

  1074.     return NGX_ERROR;
  1075. }


  1078. static ngx_int_t
  1079. ‌ngx_http_upstream_cache_send(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1080. {
  1081.     ngx_int_t          rc;
  1082.     ngx_http_cache_t  *c;

  1084.     r->cached = 1;
  1085.     c = r->cache;

  1087.     if (c->header_start == c->body_start) {
  1088.         r->http_version = NGX_HTTP_VERSION_9;
  1089.         return ngx_http_cache_send(r);
  1090.     }

  1092.     /* TODO: cache stack */

  1094.     u->buffer = *c->buf;
  1095.     u->buffer.pos += c->header_start;

  1097.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  1098.     u->headers_in.content_length_n = -1;
  1099.     u->headers_in.last_modified_time = -1;

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

  1108.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  1109.                       sizeof(ngx_table_elt_t))
  1110.         != NGX_OK)
  1111.     {
  1112.         return NGX_ERROR;
  1113.     }

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

  1117.     if (rc == NGX_OK) {

  1119.         if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  1120.             return NGX_DONE;
  1121.         }

  1123.         return ngx_http_cache_send(r);
  1124.     }

  1126.     if (rc == NGX_ERROR) {
  1127.         return NGX_ERROR;
  1128.     }

  1130.     if (rc == NGX_AGAIN || rc == NGX_HTTP_UPSTREAM_EARLY_HINTS) {
  1131.         rc = NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1132.     }

  1134.     /* rc == NGX_HTTP_UPSTREAM_INVALID_HEADER */

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

  1140.     /* TODO: delete file */

  1142.     return rc;
  1143. }


  1146. static ngx_int_t
  1147. ‌ngx_http_upstream_cache_background_update(ngx_http_request_t *r,
  1148.     ngx_http_upstream_t *u)
  1149. {
  1150.     ngx_http_request_t  *sr;

  1152.     if (r == r->main) {
  1153.         r->preserve_body = 1;
  1154.     }

  1156.     if (ngx_http_subrequest(r, &r->uri, &r->args, &sr, NULL,
  1157.                             NGX_HTTP_SUBREQUEST_CLONE
  1158.                             |NGX_HTTP_SUBREQUEST_BACKGROUND)
  1159.         != NGX_OK)
  1160.     {
  1161.         return NGX_ERROR;
  1162.     }

  1164.     sr->header_only = 1;

  1166.     return NGX_OK;
  1167. }


  1170. static ngx_int_t
  1171. ‌ngx_http_upstream_cache_check_range(ngx_http_request_t *r,
  1172.     ngx_http_upstream_t *u)
  1173. {
  1174.     off_t             offset;
  1175.     u_char           *p, *start;
  1176.     ngx_table_elt_t  *h;

  1178.     h = r->headers_in.range;

  1180.     if (h == NULL
  1181.         || !u->cacheable
  1182.         || u->conf->cache_max_range_offset == NGX_MAX_OFF_T_VALUE)
  1183.     {
  1184.         return NGX_OK;
  1185.     }

  1187.     if (u->conf->cache_max_range_offset == 0) {
  1188.         return NGX_DECLINED;
  1189.     }

  1191.     if (h->value.len < 7
  1192.         || ngx_strncasecmp(h->value.data, (u_char *) "bytes=", 6) != 0)
  1193.     {
  1194.         return NGX_OK;
  1195.     }

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

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

  1201.     if (*p == '-') {
  1202.         return NGX_DECLINED;
  1203.     }

  1205.     start = p;

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

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

  1211.     if (offset >= u->conf->cache_max_range_offset) {
  1212.         return NGX_DECLINED;
  1213.     }

  1215.     return NGX_OK;
  1216. }

  1218. #endif


  1221. static void
  1222. ‌ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
  1223. {
  1224.     ngx_uint_t                     run_posted;
  1225.     ngx_connection_t              *c;
  1226.     ngx_http_request_t            *r;
  1227.     ngx_http_upstream_t           *u;
  1228.     ngx_http_upstream_resolved_t  *ur;

  1230.     run_posted = ctx->async;

  1232.     r = ctx->data;
  1233.     c = r->connection;

  1235.     u = r->upstream;
  1236.     ur = u->resolved;

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

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

  1243.     if (ctx->state) {
  1244.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1245.                       "%V could not be resolved (%i: %s)",
  1246.                       &ctx->name, ctx->state,
  1247.                       ngx_resolver_strerror(ctx->state));

  1249.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  1250.         goto failed;
  1251.     }

  1253.     ur->naddrs = ctx->naddrs;
  1254.     ur->addrs = ctx->addrs;

  1256. #if (NGX_DEBUG)
  1257.     {
  1258.     u_char      text[NGX_SOCKADDR_STRLEN];
  1259.     ngx_str_t   addr;
  1260.     ngx_uint_t  i;

  1262.     addr.data = text;

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

  1268.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1269.                        "name was resolved to %V", &addr);
  1270.     }
  1271.     }
  1272. #endif

  1274.     if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
  1275.         ngx_http_upstream_finalize_request(r, u,
  1276.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1277.         goto failed;
  1278.     }

  1280.     ngx_resolve_name_done(ctx);
  1281.     ur->ctx = NULL;

  1283.     u->peer.start_time = ngx_current_msec;

  1285.     if (u->conf->next_upstream_tries
  1286.         && u->peer.tries > u->conf->next_upstream_tries)
  1287.     {
  1288.         u->peer.tries = u->conf->next_upstream_tries;
  1289.     }

  1291.     ngx_http_upstream_connect(r, u);

  1293. failed:

  1295.     if (run_posted) {
  1296.         ngx_http_run_posted_requests(c);
  1297.     }
  1298. }


  1301. static void
  1302. ‌ngx_http_upstream_handler(ngx_event_t *ev)
  1303. {
  1304.     ngx_connection_t     *c;
  1305.     ngx_http_request_t   *r;
  1306.     ngx_http_upstream_t  *u;

  1308.     c = ev->data;
  1309.     r = c->data;

  1311.     u = r->upstream;
  1312.     c = r->connection;

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

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

  1319.     if (ev->delayed && ev->timedout) {
  1320.         ev->delayed = 0;
  1321.         ev->timedout = 0;
  1322.     }

  1324.     if (ev->write) {
  1325.         u->write_event_handler(r, u);

  1327.     } else {
  1328.         u->read_event_handler(r, u);
  1329.     }

  1331.     ngx_http_run_posted_requests(c);
  1332. }


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


  1342. static void
  1343. ‌ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r)
  1344. {
  1345.     ngx_http_upstream_check_broken_connection(r, r->connection->write);
  1346. }


  1349. static void
  1350. ‌ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  1351.     ngx_event_t *ev)
  1352. {
  1353.     int                  n;
  1354.     char                 buf[1];
  1355.     ngx_err_t            err;
  1356.     ngx_int_t            event;
  1357.     ngx_connection_t     *c;
  1358.     ngx_http_upstream_t  *u;

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

  1364.     c = r->connection;
  1365.     u = r->upstream;

  1367.     if (c->error) {
  1368.         if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {

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

  1372.             if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1373.                 ngx_http_upstream_finalize_request(r, u,
  1374.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1375.                 return;
  1376.             }
  1377.         }

  1379.         if (!u->cacheable) {
  1380.             ngx_http_upstream_finalize_request(r, u,
  1381.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1382.         }

  1384.         return;
  1385.     }

  1387. #if (NGX_HTTP_V2)
  1388.     if (r->stream) {
  1389.         return;
  1390.     }
  1391. #endif

  1393. #if (NGX_HTTP_V3)

  1395.     if (c->quic) {
  1396.         if (c->write->error) {
  1397.             ngx_http_upstream_finalize_request(r, u,
  1398.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1399.         }

  1401.         return;
  1402.     }

  1404. #endif

  1406. #if (NGX_HAVE_KQUEUE)

  1408.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  1410.         if (!ev->pending_eof) {
  1411.             return;
  1412.         }

  1414.         ev->eof = 1;
  1415.         c->error = 1;

  1417.         if (ev->kq_errno) {
  1418.             ev->error = 1;
  1419.         }

  1421.         if (!u->cacheable && u->peer.connection) {
  1422.             ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1423.                           "kevent() reported that client prematurely closed "
  1424.                           "connection, so upstream connection is closed too");
  1425.             ngx_http_upstream_finalize_request(r, u,
  1426.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1427.             return;
  1428.         }

  1430.         ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1431.                       "kevent() reported that client prematurely closed "
  1432.                       "connection");

  1434.         if (u->peer.connection == NULL) {
  1435.             ngx_http_upstream_finalize_request(r, u,
  1436.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1437.         }

  1439.         return;
  1440.     }

  1442. #endif

  1444. #if (NGX_HAVE_EPOLLRDHUP)

  1446.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  1447.         socklen_t  len;

  1449.         if (!ev->pending_eof) {
  1450.             return;
  1451.         }

  1453.         ev->eof = 1;
  1454.         c->error = 1;

  1456.         err = 0;
  1457.         len = sizeof(ngx_err_t);

  1459.         /*
  1460.          * BSDs and Linux return 0 and set a pending error in err
  1461.          * Solaris returns -1 and sets errno
  1462.          */

  1464.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1465.             == -1)
  1466.         {
  1467.             err = ngx_socket_errno;
  1468.         }

  1470.         if (err) {
  1471.             ev->error = 1;
  1472.         }

  1474.         if (!u->cacheable && u->peer.connection) {
  1475.             ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1476.                         "epoll_wait() reported that client prematurely closed "
  1477.                         "connection, so upstream connection is closed too");
  1478.             ngx_http_upstream_finalize_request(r, u,
  1479.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1480.             return;
  1481.         }

  1483.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1484.                       "epoll_wait() reported that client prematurely closed "
  1485.                       "connection");

  1487.         if (u->peer.connection == NULL) {
  1488.             ngx_http_upstream_finalize_request(r, u,
  1489.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1490.         }

  1492.         return;
  1493.     }

  1495. #endif

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

  1499.     err = ngx_socket_errno;

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

  1504.     if (ev->write && (n >= 0 || err == NGX_EAGAIN)) {
  1505.         return;
  1506.     }

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

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

  1512.         if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1513.             ngx_http_upstream_finalize_request(r, u,
  1514.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1515.             return;
  1516.         }
  1517.     }

  1519.     if (n > 0) {
  1520.         return;
  1521.     }

  1523.     if (n == -1) {
  1524.         if (err == NGX_EAGAIN) {
  1525.             return;
  1526.         }

  1528.         ev->error = 1;

  1530.     } else { /* n == 0 */
  1531.         err = 0;
  1532.     }

  1534.     ev->eof = 1;
  1535.     c->error = 1;

  1537.     if (!u->cacheable && u->peer.connection) {
  1538.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1539.                       "client prematurely closed connection, "
  1540.                       "so upstream connection is closed too");
  1541.         ngx_http_upstream_finalize_request(r, u,
  1542.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1543.         return;
  1544.     }

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

  1549.     if (u->peer.connection == NULL) {
  1550.         ngx_http_upstream_finalize_request(r, u,
  1551.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1552.     }
  1553. }


  1556. static void
  1557. ‌ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1558. {
  1559.     ngx_int_t                  rc;
  1560.     ngx_connection_t          *c;
  1561.     ngx_http_core_loc_conf_t  *clcf;

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

  1565.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  1566.         u->state->response_time = ngx_current_msec - u->start_time;
  1567.     }

  1569.     u->state = ngx_array_push(r->upstream_states);
  1570.     if (u->state == NULL) {
  1571.         ngx_http_upstream_finalize_request(r, u,
  1572.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1573.         return;
  1574.     }

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

  1578.     u->start_time = ngx_current_msec;

  1580.     u->state->response_time = (ngx_msec_t) -1;
  1581.     u->state->connect_time = (ngx_msec_t) -1;
  1582.     u->state->header_time = (ngx_msec_t) -1;

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

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

  1589.     if (rc == NGX_ERROR) {
  1590.         ngx_http_upstream_finalize_request(r, u,
  1591.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1592.         return;
  1593.     }

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

  1597. #if (NGX_HTTP_UPSTREAM_ZONE)
  1598.     if (u->upstream && u->upstream->shm_zone
  1599.         && (u->upstream->flags & NGX_HTTP_UPSTREAM_MODIFY))
  1600.     {
  1601.         u->state->peer = ngx_palloc(r->pool,
  1602.                                     sizeof(ngx_str_t) + u->peer.name->len);
  1603.         if (u->state->peer == NULL) {
  1604.             ngx_http_upstream_finalize_request(r, u,
  1605.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1606.             return;
  1607.         }

  1609.         u->state->peer->len = u->peer.name->len;
  1610.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  1611.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  1613.         u->peer.name = u->state->peer;
  1614.     }
  1615. #endif

  1617.     if (rc == NGX_BUSY) {
  1618.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
  1619.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);
  1620.         return;
  1621.     }

  1623.     if (rc == NGX_DECLINED) {
  1624.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1625.         return;
  1626.     }

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

  1630.     c = u->peer.connection;

  1632.     c->requests++;

  1634.     c->data = r;

  1636.     c->write->handler = ngx_http_upstream_handler;
  1637.     c->read->handler = ngx_http_upstream_handler;

  1639.     u->write_event_handler = ngx_http_upstream_send_request_handler;
  1640.     u->read_event_handler = ngx_http_upstream_process_header;

  1642.     c->sendfile &= r->connection->sendfile;
  1643.     u->output.sendfile = c->sendfile;

  1645.     if (r->connection->tcp_nopush == NGX_TCP_NOPUSH_DISABLED) {
  1646.         c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1647.     }

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

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

  1653.         c->pool = ngx_create_pool(128, r->connection->log);
  1654.         if (c->pool == NULL) {
  1655.             ngx_http_upstream_finalize_request(r, u,
  1656.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1657.             return;
  1658.         }
  1659.     }

  1661.     c->log = r->connection->log;
  1662.     c->pool->log = c->log;
  1663.     c->read->log = c->log;
  1664.     c->write->log = c->log;

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

  1668.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1670.     u->writer.out = NULL;
  1671.     u->writer.last = &u->writer.out;
  1672.     u->writer.connection = c;
  1673.     u->writer.limit = clcf->sendfile_max_chunk;

  1675.     if (u->request_sent || u->response_received) {
  1676.         if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
  1677.             ngx_http_upstream_finalize_request(r, u,
  1678.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1679.             return;
  1680.         }
  1681.     }

  1683.     if (r->request_body
  1684.         && r->request_body->buf
  1685.         && r->request_body->temp_file
  1686.         && r == r->main)
  1687.     {
  1688.         /*
  1689.          * the r->request_body->buf can be reused for one request only,
  1690.          * the subrequests should allocate their own temporary bufs
  1691.          */

  1693.         u->output.free = ngx_alloc_chain_link(r->pool);
  1694.         if (u->output.free == NULL) {
  1695.             ngx_http_upstream_finalize_request(r, u,
  1696.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1697.             return;
  1698.         }

  1700.         u->output.free->buf = r->request_body->buf;
  1701.         u->output.free->next = NULL;
  1702.         u->output.allocated = 1;

  1704.         r->request_body->buf->pos = r->request_body->buf->start;
  1705.         r->request_body->buf->last = r->request_body->buf->start;
  1706.         r->request_body->buf->tag = u->output.tag;
  1707.     }

  1709.     u->request_sent = 0;
  1710.     u->request_body_sent = 0;
  1711.     u->request_body_blocked = 0;
  1712.     u->response_received = 0;

  1714.     if (rc == NGX_AGAIN) {
  1715.         ngx_add_timer(c->write, u->conf->connect_timeout);
  1716.         return;
  1717.     }

  1719. #if (NGX_HTTP_SSL)

  1721.     if (u->ssl && c->ssl == NULL) {
  1722.         ngx_http_upstream_ssl_init_connection(r, u, c);
  1723.         return;
  1724.     }

  1726. #endif

  1728.     ngx_http_upstream_send_request(r, u, 1);
  1729. }


  1732. #if (NGX_HTTP_SSL)

  1734. static void
  1735. ‌ngx_http_upstream_ssl_init_connection(ngx_http_request_t *r,
  1736.     ngx_http_upstream_t *u, ngx_connection_t *c)
  1737. {
  1738.     ngx_int_t                  rc;
  1739.     ngx_http_core_loc_conf_t  *clcf;

  1741.     if (ngx_http_upstream_test_connect(c) != NGX_OK) {
  1742.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1743.         return;
  1744.     }

  1746.     if (ngx_ssl_create_connection(u->conf->ssl, c,
  1747.                                   NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1748.         != NGX_OK)
  1749.     {
  1750.         ngx_http_upstream_finalize_request(r, u,
  1751.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1752.         return;
  1753.     }

  1755.     if (u->conf->ssl_server_name || u->conf->ssl_verify) {
  1756.         if (ngx_http_upstream_ssl_name(r, u, c) != NGX_OK) {
  1757.             ngx_http_upstream_finalize_request(r, u,
  1758.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1759.             return;
  1760.         }
  1761.     }

  1763.     if (u->conf->ssl_certificate
  1764.         && u->conf->ssl_certificate->value.len
  1765.         && (u->conf->ssl_certificate->lengths
  1766.             || u->conf->ssl_certificate_key->lengths))
  1767.     {
  1768.         if (ngx_http_upstream_ssl_certificate(r, u, c) != NGX_OK) {
  1769.             ngx_http_upstream_finalize_request(r, u,
  1770.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1771.             return;
  1772.         }
  1773.     }

  1775. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1777.     if (u->ssl_alpn_protocol.len) {
  1778.         if (SSL_set_alpn_protos(c->ssl->connection, u->ssl_alpn_protocol.data,
  1779.                                 u->ssl_alpn_protocol.len)
  1780.             != 0)
  1781.         {
  1782.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  1783.                           "SSL_set_alpn_protos() failed");
  1784.             ngx_http_upstream_finalize_request(r, u,
  1785.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1786.             return;
  1787.         }
  1788.     }

  1790. #endif

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

  1795.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1796.             ngx_http_upstream_finalize_request(r, u,
  1797.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1798.             return;
  1799.         }

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

  1803.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1805.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  1806.             ngx_http_upstream_finalize_request(r, u,
  1807.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1808.             return;
  1809.         }
  1810.     }

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

  1814.     rc = ngx_ssl_handshake(c);

  1816.     if (rc == NGX_AGAIN) {

  1818.         if (!c->write->timer_set) {
  1819.             ngx_add_timer(c->write, u->conf->connect_timeout);
  1820.         }

  1822.         c->ssl->handler = ngx_http_upstream_ssl_handshake_handler;
  1823.         return;
  1824.     }

  1826.     ngx_http_upstream_ssl_handshake(r, u, c);
  1827. }


  1830. static void
  1831. ‌ngx_http_upstream_ssl_handshake_handler(ngx_connection_t *c)
  1832. {
  1833.     ngx_http_request_t   *r;
  1834.     ngx_http_upstream_t  *u;

  1836.     r = c->data;

  1838.     u = r->upstream;
  1839.     c = r->connection;

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

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

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

  1849.     ngx_http_run_posted_requests(c);
  1850. }


  1853. static void
  1854. ‌ngx_http_upstream_ssl_handshake(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1855.     ngx_connection_t *c)
  1856. {
  1857.     long  rc;

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

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

  1864.             if (rc != X509_V_OK) {
  1865.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1866.                               "upstream SSL certificate verify error: (%l:%s)",
  1867.                               rc, X509_verify_cert_error_string(rc));
  1868.                 goto failed;
  1869.             }

  1871.             if (ngx_ssl_check_host(c, &u->ssl_name) != NGX_OK) {
  1872.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1873.                               "upstream SSL certificate does not match \"%V\"",
  1874.                               &u->ssl_name);
  1875.                 goto failed;
  1876.             }
  1877.         }

  1879.         if (!c->ssl->sendfile) {
  1880.             c->sendfile = 0;
  1881.             u->output.sendfile = 0;
  1882.         }

  1884.         c->write->handler = ngx_http_upstream_handler;
  1885.         c->read->handler = ngx_http_upstream_handler;

  1887.         ngx_http_upstream_send_request(r, u, 1);

  1889.         return;
  1890.     }

  1892.     if (c->write->timedout) {
  1893.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  1894.         return;
  1895.     }

  1897. failed:

  1899.     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1900. }


  1903. static void
  1904. ‌ngx_http_upstream_ssl_save_session(ngx_connection_t *c)
  1905. {
  1906.     ngx_http_request_t   *r;
  1907.     ngx_http_upstream_t  *u;

  1909.     if (c->idle) {
  1910.         return;
  1911.     }

  1913.     r = c->data;

  1915.     u = r->upstream;
  1916.     c = r->connection;

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

  1920.     u->peer.save_session(&u->peer, u->peer.data);
  1921. }


  1924. static ngx_int_t
  1925. ‌ngx_http_upstream_ssl_name(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1926.     ngx_connection_t *c)
  1927. {
  1928.     u_char     *p, *last;
  1929.     ngx_str_t   name;

  1931.     if (u->conf->ssl_name) {
  1932.         if (ngx_http_complex_value(r, u->conf->ssl_name, &name) != NGX_OK) {
  1933.             return NGX_ERROR;
  1934.         }

  1936.     } else {
  1937.         name = u->ssl_name;
  1938.     }

  1940.     if (name.len == 0) {
  1941.         goto done;
  1942.     }

  1944.     /*
  1945.      * ssl name here may contain port, notably if derived from $proxy_host
  1946.      * or $http_host; we have to strip it
  1947.      */

  1949.     p = name.data;
  1950.     last = name.data + name.len;

  1952.     if (*p == '[') {
  1953.         p = ngx_strlchr(p, last, ']');

  1955.         if (p == NULL) {
  1956.             p = name.data;
  1957.         }
  1958.     }

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

  1962.     if (p != NULL) {
  1963.         name.len = p - name.data;
  1964.     }

  1966.     if (!u->conf->ssl_server_name) {
  1967.         goto done;
  1968.     }

  1970. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  1974.     if (name.len == 0 || *name.data == '[') {
  1975.         goto done;
  1976.     }

  1978.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1979.         goto done;
  1980.     }

  1982.     /*
  1983.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1984.      * hence we explicitly null-terminate name here
  1985.      */

  1987.     p = ngx_pnalloc(r->pool, name.len + 1);
  1988.     if (p == NULL) {
  1989.         return NGX_ERROR;
  1990.     }

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

  1994.     name.data = p;

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

  1999.     if (SSL_set_tlsext_host_name(c->ssl->connection,
  2000.                                  (char *) name.data)
  2001.         == 0)
  2002.     {
  2003.         ngx_ssl_error(NGX_LOG_ERR, r->connection->log, 0,
  2004.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  2005.         return NGX_ERROR;
  2006.     }

  2008. #endif

  2010. done:

  2012.     u->ssl_name = name;

  2014.     return NGX_OK;
  2015. }


  2018. static ngx_int_t
  2019. ‌ngx_http_upstream_ssl_certificate(ngx_http_request_t *r,
  2020.     ngx_http_upstream_t *u, ngx_connection_t *c)
  2021. {
  2022.     ngx_str_t  cert, key;

  2024.     if (ngx_http_complex_value(r, u->conf->ssl_certificate, &cert)
  2025.         != NGX_OK)
  2026.     {
  2027.         return NGX_ERROR;
  2028.     }

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

  2033.     if (*cert.data == '\0') {
  2034.         return NGX_OK;
  2035.     }

  2037.     if (ngx_http_complex_value(r, u->conf->ssl_certificate_key, &key)
  2038.         != NGX_OK)
  2039.     {
  2040.         return NGX_ERROR;
  2041.     }

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

  2046.     if (ngx_ssl_connection_certificate(c, r->pool, &cert, &key,
  2047.                                        u->conf->ssl_certificate_cache,
  2048.                                        u->conf->ssl_passwords)
  2049.         != NGX_OK)
  2050.     {
  2051.         return NGX_ERROR;
  2052.     }

  2054.     return NGX_OK;
  2055. }

  2057. #endif


  2060. static ngx_int_t
  2061. ‌ngx_http_upstream_reinit(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2062. {
  2063.     off_t         file_pos;
  2064.     ngx_chain_t  *cl;

  2066.     if (u->reinit_request(r) != NGX_OK) {
  2067.         return NGX_ERROR;
  2068.     }

  2070.     u->early_hints_length = 0;
  2071.     u->keepalive = 0;
  2072.     u->upgrade = 0;
  2073.     u->error = 0;

  2075.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2076.     u->headers_in.content_length_n = -1;
  2077.     u->headers_in.last_modified_time = -1;

  2079.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2080.                       sizeof(ngx_table_elt_t))
  2081.         != NGX_OK)
  2082.     {
  2083.         return NGX_ERROR;
  2084.     }

  2086.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2087.                       sizeof(ngx_table_elt_t))
  2088.         != NGX_OK)
  2089.     {
  2090.         return NGX_ERROR;
  2091.     }

  2093.     /* reinit the request chain */

  2095.     file_pos = 0;

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

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

  2102.         if (cl->buf->in_file) {
  2103.             cl->buf->file_pos = file_pos;
  2104.             file_pos = cl->buf->file_last;
  2105.         }
  2106.     }

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

  2110.     if (r->request_body && r->request_body->temp_file
  2111.         && r != r->main && u->output.buf)
  2112.     {
  2113.         u->output.free = ngx_alloc_chain_link(r->pool);
  2114.         if (u->output.free == NULL) {
  2115.             return NGX_ERROR;
  2116.         }

  2118.         u->output.free->buf = u->output.buf;
  2119.         u->output.free->next = NULL;

  2121.         u->output.buf->pos = u->output.buf->start;
  2122.         u->output.buf->last = u->output.buf->start;
  2123.     }

  2125.     u->output.buf = NULL;
  2126.     u->output.in = NULL;
  2127.     u->output.busy = NULL;

  2129.     /* reinit u->buffer */

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

  2133. #if (NGX_HTTP_CACHE)

  2135.     if (r->cache) {
  2136.         u->buffer.pos += r->cache->header_start;
  2137.     }

  2139. #endif

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

  2143.     return NGX_OK;
  2144. }


  2147. static void
  2148. ‌ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u,
  2149.     ngx_uint_t do_write)
  2150. {
  2151.     ngx_int_t          rc;
  2152.     ngx_connection_t  *c;

  2154.     c = u->peer.connection;

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

  2159.     if (u->state->connect_time == (ngx_msec_t) -1) {
  2160.         u->state->connect_time = ngx_current_msec - u->start_time;
  2161.     }

  2163.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2164.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2165.         return;
  2166.     }

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

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

  2172.     if (rc == NGX_ERROR) {
  2173.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2174.         return;
  2175.     }

  2177.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2178.         ngx_http_upstream_finalize_request(r, u, rc);
  2179.         return;
  2180.     }

  2182.     if (rc == NGX_AGAIN) {
  2183.         if (!c->write->ready || u->request_body_blocked) {
  2184.             ngx_add_timer(c->write, u->conf->send_timeout);

  2186.         } else if (c->write->timer_set) {
  2187.             ngx_del_timer(c->write);
  2188.         }

  2190.         if (ngx_handle_write_event(c->write, u->conf->send_lowat) != NGX_OK) {
  2191.             ngx_http_upstream_finalize_request(r, u,
  2192.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2193.             return;
  2194.         }

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

  2205.             c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2206.         }

  2208.         if (c->read->ready) {
  2209.             ngx_post_event(c->read, &ngx_posted_events);
  2210.         }

  2212.         return;
  2213.     }

  2215.     /* rc == NGX_OK */

  2217.     if (c->write->timer_set) {
  2218.         ngx_del_timer(c->write);
  2219.     }

  2221.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2222.         if (ngx_tcp_push(c->fd) == -1) {
  2223.             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2224.                           ngx_tcp_push_n " failed");
  2225.             ngx_http_upstream_finalize_request(r, u,
  2226.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2227.             return;
  2228.         }

  2230.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2231.     }

  2233.     if (!u->conf->preserve_output) {
  2234.         u->write_event_handler = ngx_http_upstream_dummy_handler;
  2235.     }

  2237.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2238.         ngx_http_upstream_finalize_request(r, u,
  2239.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2240.         return;
  2241.     }

  2243.     if (!u->request_body_sent) {
  2244.         u->request_body_sent = 1;

  2246.         if (u->header_sent) {
  2247.             return;
  2248.         }

  2250.         if (u->conf->ignore_input) {
  2251.             ngx_http_upstream_process_header(r, u);
  2252.             return;
  2253.         }

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

  2257.         if (c->read->ready) {
  2258.             ngx_http_upstream_process_header(r, u);
  2259.             return;
  2260.         }
  2261.     }
  2262. }


  2265. static ngx_int_t
  2266. ‌ngx_http_upstream_send_request_body(ngx_http_request_t *r,
  2267.     ngx_http_upstream_t *u, ngx_uint_t do_write)
  2268. {
  2269.     ngx_int_t                  rc;
  2270.     ngx_chain_t               *out, *cl, *ln;
  2271.     ngx_connection_t          *c;
  2272.     ngx_http_core_loc_conf_t  *clcf;

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

  2277.     if (!r->request_body_no_buffering) {

  2279.         /* buffered request body */

  2281.         if (!u->request_sent) {
  2282.             u->request_sent = 1;
  2283.             out = u->request_bufs;

  2285.         } else {
  2286.             out = NULL;
  2287.         }

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

  2291.         if (rc == NGX_AGAIN) {
  2292.             u->request_body_blocked = 1;

  2294.         } else {
  2295.             u->request_body_blocked = 0;
  2296.         }

  2298.         return rc;
  2299.     }

  2301.     if (!u->request_sent) {
  2302.         u->request_sent = 1;
  2303.         out = u->request_bufs;

  2305.         if (r->request_body->bufs) {
  2306.             for (cl = out; cl->next; cl = cl->next) { /* void */ }
  2307.             cl->next = r->request_body->bufs;
  2308.             r->request_body->bufs = NULL;
  2309.         }

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

  2314.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  2315.             return NGX_ERROR;
  2316.         }

  2318.         r->read_event_handler = ngx_http_upstream_read_request_handler;

  2320.     } else {
  2321.         out = NULL;
  2322.     }

  2324.     for ( ;; ) {

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

  2329.             if (rc == NGX_ERROR) {
  2330.                 return NGX_ERROR;
  2331.             }

  2333.             while (out) {
  2334.                 ln = out;
  2335.                 out = out->next;
  2336.                 ngx_free_chain(r->pool, ln);
  2337.             }

  2339.             if (rc == NGX_AGAIN) {
  2340.                 u->request_body_blocked = 1;

  2342.             } else {
  2343.                 u->request_body_blocked = 0;
  2344.             }

  2346.             if (rc == NGX_OK && !r->reading_body) {
  2347.                 break;
  2348.             }
  2349.         }

  2351.         if (r->reading_body) {
  2352.             /* read client request body */

  2354.             rc = ngx_http_read_unbuffered_request_body(r);

  2356.             if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2357.                 return rc;
  2358.             }

  2360.             out = r->request_body->bufs;
  2361.             r->request_body->bufs = NULL;
  2362.         }

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

  2366.         if (out == NULL) {
  2367.             rc = NGX_AGAIN;
  2368.             break;
  2369.         }

  2371.         do_write = 1;
  2372.     }

  2374.     if (!r->reading_body) {
  2375.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2376.             r->read_event_handler =
  2377.                                   ngx_http_upstream_rd_check_broken_connection;
  2378.         }
  2379.     }

  2381.     return rc;
  2382. }


  2385. static void
  2386. ‌ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  2387.     ngx_http_upstream_t *u)
  2388. {
  2389.     ngx_connection_t  *c;

  2391.     c = u->peer.connection;

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

  2396.     if (c->write->timedout) {
  2397.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2398.         return;
  2399.     }

  2401. #if (NGX_HTTP_SSL)

  2403.     if (u->ssl && c->ssl == NULL) {
  2404.         ngx_http_upstream_ssl_init_connection(r, u, c);
  2405.         return;
  2406.     }

  2408. #endif

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

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

  2415.         return;
  2416.     }

  2418.     ngx_http_upstream_send_request(r, u, 1);
  2419. }


  2422. static void
  2423. ‌ngx_http_upstream_read_request_handler(ngx_http_request_t *r)
  2424. {
  2425.     ngx_connection_t     *c;
  2426.     ngx_http_upstream_t  *u;

  2428.     c = r->connection;
  2429.     u = r->upstream;

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

  2434.     if (c->read->timedout) {
  2435.         c->timedout = 1;
  2436.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  2437.         return;
  2438.     }

  2440.     ngx_http_upstream_send_request(r, u, 0);
  2441. }


  2444. static void
  2445. ‌ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2446. {
  2447.     ssize_t            n;
  2448.     ngx_int_t          rc;
  2449.     ngx_connection_t  *c;

  2451.     c = u->peer.connection;

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

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

  2458.     if (c->read->timedout) {
  2459.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2460.         return;
  2461.     }

  2463.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2464.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2465.         return;
  2466.     }

  2468.     if (u->buffer.start == NULL) {
  2469.         u->buffer.start = ngx_palloc(r->pool, u->conf->buffer_size);
  2470.         if (u->buffer.start == NULL) {
  2471.             ngx_http_upstream_finalize_request(r, u,
  2472.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2473.             return;
  2474.         }

  2476.         u->buffer.pos = u->buffer.start;
  2477.         u->buffer.last = u->buffer.start;
  2478.         u->buffer.end = u->buffer.start + u->conf->buffer_size;
  2479.         u->buffer.temporary = 1;

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

  2483.         if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2484.                           sizeof(ngx_table_elt_t))
  2485.             != NGX_OK)
  2486.         {
  2487.             ngx_http_upstream_finalize_request(r, u,
  2488.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2489.             return;
  2490.         }

  2492.         if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2493.                           sizeof(ngx_table_elt_t))
  2494.             != NGX_OK)
  2495.         {
  2496.             ngx_http_upstream_finalize_request(r, u,
  2497.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2498.             return;
  2499.         }

  2501. #if (NGX_HTTP_CACHE)

  2503.         if (r->cache) {
  2504.             u->buffer.pos += r->cache->header_start;
  2505.             u->buffer.last = u->buffer.pos;
  2506.         }
  2507. #endif
  2508.     }

  2510.     if (u->conf->ignore_input) {
  2511.         rc = u->process_header(r);
  2512.         goto done;
  2513.     }

  2515.     for ( ;; ) {

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

  2519.         if (n == NGX_AGAIN) {
  2520. #if 0
  2521.             ngx_add_timer(rev, u->read_timeout);
  2522. #endif

  2524.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2525.                 ngx_http_upstream_finalize_request(r, u,
  2526.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2527.                 return;
  2528.             }

  2530.             return;
  2531.         }

  2533.         if (n == 0) {
  2534.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2535.                           "upstream prematurely closed connection");
  2536.         }

  2538.         if (n == NGX_ERROR || n == 0) {
  2539.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2540.             return;
  2541.         }

  2543. #if (NGX_HTTP_SSL)
  2544.         if (u->ssl && c->ssl == NULL) {
  2545.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2546.                           "upstream prematurely sent response");
  2547.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2548.             return;
  2549.         }
  2550. #endif

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

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

  2556. #if 0
  2557.         u->valid_header_in = 0;

  2559.         u->peer.cached = 0;
  2560. #endif

  2562.         u->response_received = 1;

  2564. again:

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

  2568.         if (rc == NGX_AGAIN) {

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

  2574.                 ngx_http_upstream_next(r, u,
  2575.                                        NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2576.                 return;
  2577.             }

  2579.             continue;
  2580.         }

  2582.         if (rc == NGX_HTTP_UPSTREAM_EARLY_HINTS) {
  2583.             rc = ngx_http_upstream_process_early_hints(r, u);

  2585.             if (rc == NGX_OK) {
  2586.                 goto again;
  2587.             }
  2588.         }

  2590.         break;
  2591.     }

  2593. done:

  2595.     if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2596.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2597.         return;
  2598.     }

  2600.     if (rc == NGX_ERROR) {
  2601.         ngx_http_upstream_finalize_request(r, u,
  2602.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2603.         return;
  2604.     }

  2606.     /* rc == NGX_OK */

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

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

  2612.         if (ngx_http_upstream_test_next(r, u) == NGX_OK) {
  2613.             return;
  2614.         }

  2616.         if (ngx_http_upstream_intercept_errors(r, u) == NGX_OK) {
  2617.             return;
  2618.         }
  2619.     }

  2621.     if (u->peer.notify) {
  2622.         u->peer.notify(&u->peer, u->peer.data, NGX_HTTP_UPSTREAM_NOTIFY_HEADER);
  2623.     }

  2625.     if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  2626.         return;
  2627.     }

  2629.     ngx_http_upstream_send_response(r, u);
  2630. }


  2633. static ngx_int_t
  2634. ‌ngx_http_upstream_process_early_hints(ngx_http_request_t *r,
  2635.     ngx_http_upstream_t *u)
  2636. {
  2637.     u_char            *p;
  2638.     ngx_uint_t         i;
  2639.     ngx_list_part_t   *part;
  2640.     ngx_table_elt_t   *h, *ho;
  2641.     ngx_connection_t  *c;

  2643.     c = r->connection;

  2645.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0, "http upstream early hints");

  2647.     if (u->conf->pass_early_hints) {

  2649.         u->early_hints_length += u->buffer.pos - u->buffer.start;

  2651.         if (u->early_hints_length <= (off_t) u->conf->buffer_size) {

  2653.             part = &u->headers_in.headers.part;
  2654.             h = part->elts;

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

  2658.                 if (i >= part->nelts) {
  2659.                     if (part->next == NULL) {
  2660.                         break;
  2661.                     }

  2663.                     part = part->next;
  2664.                     h = part->elts;
  2665.                     i = 0;
  2666.                 }

  2668.                 if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  2669.                                   h[i].lowcase_key, h[i].key.len))
  2670.                 {
  2671.                     continue;
  2672.                 }

  2674.                 ho = ngx_list_push(&r->headers_out.headers);
  2675.                 if (ho == NULL) {
  2676.                     return NGX_ERROR;
  2677.                 }

  2679.                 *ho = h[i];
  2680.             }

  2682.             if (ngx_http_send_early_hints(r) == NGX_ERROR) {
  2683.                 return NGX_ERROR;
  2684.             }

  2686.             if (c->buffered) {
  2687.                 if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2688.                     return NGX_ERROR;
  2689.                 }

  2691.                 r->write_event_handler = ngx_http_upstream_early_hints_writer;
  2692.             }

  2694.         } else {
  2695.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2696.                           "upstream sent too big early hints");
  2697.         }
  2698.     }

  2700.     ngx_http_clean_header(r);

  2702.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2703.     u->headers_in.content_length_n = -1;
  2704.     u->headers_in.last_modified_time = -1;

  2706.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2707.                       sizeof(ngx_table_elt_t))
  2708.         != NGX_OK)
  2709.     {
  2710.         return NGX_ERROR;
  2711.     }

  2713.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2714.                       sizeof(ngx_table_elt_t))
  2715.         != NGX_OK)
  2716.     {
  2717.         return NGX_ERROR;
  2718.     }

  2720.     p = u->buffer.pos;

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

  2724. #if (NGX_HTTP_CACHE)

  2726.     if (r->cache) {
  2727.         u->buffer.pos += r->cache->header_start;
  2728.     }

  2730. #endif

  2732.     u->buffer.last = ngx_movemem(u->buffer.pos, p, u->buffer.last - p);

  2734.     return NGX_OK;
  2735. }


  2738. static void
  2739. ‌ngx_http_upstream_early_hints_writer(ngx_http_request_t *r)
  2740. {
  2741.     ngx_connection_t     *c;
  2742.     ngx_http_upstream_t  *u;

  2744.     c = r->connection;
  2745.     u = r->upstream;

  2747.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  2748.                    "http upstream early hints writer");

  2750.     c->log->action = "sending early hints to client";

  2752.     if (ngx_http_write_filter(r, NULL) == NGX_ERROR) {
  2753.         ngx_http_upstream_finalize_request(r, u,
  2754.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2755.         return;
  2756.     }

  2758.     if (!c->buffered) {
  2759.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2760.             r->write_event_handler =
  2761.                                   ngx_http_upstream_wr_check_broken_connection;

  2763.         } else {
  2764.             r->write_event_handler = ngx_http_request_empty_handler;
  2765.         }
  2766.     }

  2768.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2769.         ngx_http_upstream_finalize_request(r, u,
  2770.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2771.     }
  2772. }


  2775. static ngx_int_t
  2776. ‌ngx_http_upstream_test_next(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2777. {
  2778.     ngx_msec_t                 timeout;
  2779.     ngx_uint_t                 status, mask;
  2780.     ngx_http_upstream_next_t  *un;

  2782.     status = u->headers_in.status_n;

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

  2786.         if (status != un->status) {
  2787.             continue;
  2788.         }

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

  2792.         if (u->request_sent
  2793.             && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  2794.         {
  2795.             mask = un->mask | NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;

  2797.         } else {
  2798.             mask = un->mask;
  2799.         }

  2801.         if (u->peer.tries > 1
  2802.             && ((u->conf->next_upstream & mask) == mask)
  2803.             && !(u->request_sent && r->request_body_no_buffering)
  2804.             && !(timeout && ngx_current_msec - u->peer.start_time >= timeout))
  2805.         {
  2806.             ngx_http_upstream_next(r, u, un->mask);
  2807.             return NGX_OK;
  2808.         }

  2810. #if (NGX_HTTP_CACHE)

  2812.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2813.             && (u->conf->cache_use_stale & un->mask))
  2814.         {
  2815.             ngx_int_t  rc;

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

  2819.             if (rc != NGX_OK) {
  2820.                 ngx_http_upstream_finalize_request(r, u, rc);
  2821.                 return NGX_OK;
  2822.             }

  2824.             u->cache_status = NGX_HTTP_CACHE_STALE;
  2825.             rc = ngx_http_upstream_cache_send(r, u);

  2827.             if (rc == NGX_DONE) {
  2828.                 return NGX_OK;
  2829.             }

  2831.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2832.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2833.             }

  2835.             ngx_http_upstream_finalize_request(r, u, rc);
  2836.             return NGX_OK;
  2837.         }

  2839. #endif

  2841.         break;
  2842.     }

  2844. #if (NGX_HTTP_CACHE)

  2846.     if (status == NGX_HTTP_NOT_MODIFIED
  2847.         && u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2848.         && u->conf->cache_revalidate)
  2849.     {
  2850.         time_t     now, valid, updating, error;
  2851.         ngx_int_t  rc;

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

  2856.         now = ngx_time();

  2858.         valid = r->cache->valid_sec;
  2859.         updating = r->cache->updating_sec;
  2860.         error = r->cache->error_sec;

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

  2864.         if (rc != NGX_OK) {
  2865.             ngx_http_upstream_finalize_request(r, u, rc);
  2866.             return NGX_OK;
  2867.         }

  2869.         u->cache_status = NGX_HTTP_CACHE_REVALIDATED;
  2870.         rc = ngx_http_upstream_cache_send(r, u);

  2872.         if (rc == NGX_DONE) {
  2873.             return NGX_OK;
  2874.         }

  2876.         if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2877.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2878.         }

  2880.         if (valid == 0) {
  2881.             valid = r->cache->valid_sec;
  2882.             updating = r->cache->updating_sec;
  2883.             error = r->cache->error_sec;
  2884.         }

  2886.         if (valid == 0) {
  2887.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2888.                                               u->headers_in.status_n);
  2889.             if (valid) {
  2890.                 valid = now + valid;
  2891.             }
  2892.         }

  2894.         if (valid) {
  2895.             r->cache->valid_sec = valid;
  2896.             r->cache->updating_sec = updating;
  2897.             r->cache->error_sec = error;

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

  2901.             ngx_http_file_cache_update_header(r);
  2902.         }

  2904.         ngx_http_upstream_finalize_request(r, u, rc);
  2905.         return NGX_OK;
  2906.     }

  2908. #endif

  2910.     return NGX_DECLINED;
  2911. }


  2914. static ngx_int_t
  2915. ‌ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  2916.     ngx_http_upstream_t *u)
  2917. {
  2918.     ngx_int_t                  status;
  2919.     ngx_uint_t                 i;
  2920.     ngx_table_elt_t           *h, *ho, **ph;
  2921.     ngx_http_err_page_t       *err_page;
  2922.     ngx_http_core_loc_conf_t  *clcf;

  2924.     status = u->headers_in.status_n;

  2926.     if (status == NGX_HTTP_NOT_FOUND && u->conf->intercept_404) {
  2927.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_NOT_FOUND);
  2928.         return NGX_OK;
  2929.     }

  2931.     if (!u->conf->intercept_errors) {
  2932.         return NGX_DECLINED;
  2933.     }

  2935.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2937.     if (clcf->error_pages == NULL) {
  2938.         return NGX_DECLINED;
  2939.     }

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

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

  2946.             if (status == NGX_HTTP_UNAUTHORIZED
  2947.                 && u->headers_in.www_authenticate)
  2948.             {
  2949.                 h = u->headers_in.www_authenticate;
  2950.                 ph = &r->headers_out.www_authenticate;

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

  2955.                     if (ho == NULL) {
  2956.                         ngx_http_upstream_finalize_request(r, u,
  2957.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2958.                         return NGX_OK;
  2959.                     }

  2961.                     *ho = *h;
  2962.                     ho->next = NULL;

  2964.                     *ph = ho;
  2965.                     ph = &ho->next;

  2967.                     h = h->next;
  2968.                 }
  2969.             }

  2971. #if (NGX_HTTP_CACHE)

  2973.             if (r->cache) {

  2975.                 if (u->headers_in.no_cache || u->headers_in.expired) {
  2976.                     u->cacheable = 0;
  2977.                 }

  2979.                 if (u->cacheable) {
  2980.                     time_t  valid;

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

  2984.                     if (valid == 0) {
  2985.                         valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2986.                                                           status);
  2987.                         if (valid) {
  2988.                             r->cache->valid_sec = ngx_time() + valid;
  2989.                         }
  2990.                     }

  2992.                     if (valid) {
  2993.                         r->cache->error = status;
  2994.                     }
  2995.                 }

  2997.                 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  2998.             }
  2999. #endif
  3000.             ngx_http_upstream_finalize_request(r, u, status);

  3002.             return NGX_OK;
  3003.         }
  3004.     }

  3006.     return NGX_DECLINED;
  3007. }


  3010. static ngx_int_t
  3011. ‌ngx_http_upstream_test_connect(ngx_connection_t *c)
  3012. {
  3013.     int        err;
  3014.     socklen_t  len;

  3016. #if (NGX_HAVE_KQUEUE)

  3018.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
  3019.         if (c->write->pending_eof || c->read->pending_eof) {
  3020.             if (c->write->pending_eof) {
  3021.                 err = c->write->kq_errno;

  3023.             } else {
  3024.                 err = c->read->kq_errno;
  3025.             }

  3027.             c->log->action = "connecting to upstream";
  3028.             (void) ngx_connection_error(c, err,
  3029.                                     "kevent() reported that connect() failed");
  3030.             return NGX_ERROR;
  3031.         }

  3033.     } else
  3034. #endif
  3035.     {
  3036.         err = 0;
  3037.         len = sizeof(int);

  3039.         /*
  3040.          * BSDs and Linux return 0 and set a pending error in err
  3041.          * Solaris returns -1 and sets errno
  3042.          */

  3044.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3045.             == -1)
  3046.         {
  3047.             err = ngx_socket_errno;
  3048.         }

  3050.         if (err) {
  3051.             c->log->action = "connecting to upstream";
  3052.             (void) ngx_connection_error(c, err, "connect() failed");
  3053.             return NGX_ERROR;
  3054.         }
  3055.     }

  3057.     return NGX_OK;
  3058. }


  3061. static ngx_int_t
  3062. ‌ngx_http_upstream_process_headers(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3063. {
  3064.     ngx_str_t                       uri, args;
  3065.     ngx_uint_t                      i, flags;
  3066.     ngx_list_part_t                *part;
  3067.     ngx_table_elt_t                *h;
  3068.     ngx_http_upstream_header_t     *hh;
  3069.     ngx_http_upstream_main_conf_t  *umcf;

  3071.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  3073.     if (u->headers_in.no_cache || u->headers_in.expired) {
  3074.         u->cacheable = 0;
  3075.     }

  3077.     if (u->headers_in.x_accel_redirect
  3078.         && !(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT))
  3079.     {
  3080.         ngx_http_upstream_finalize_request(r, u, NGX_DECLINED);

  3082.         part = &u->headers_in.headers.part;
  3083.         h = part->elts;

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

  3087.             if (i >= part->nelts) {
  3088.                 if (part->next == NULL) {
  3089.                     break;
  3090.                 }

  3092.                 part = part->next;
  3093.                 h = part->elts;
  3094.                 i = 0;
  3095.             }

  3097.             if (h[i].hash == 0) {
  3098.                 continue;
  3099.             }

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

  3104.             if (hh && hh->redirect) {
  3105.                 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  3106.                     ngx_http_finalize_request(r,
  3107.                                               NGX_HTTP_INTERNAL_SERVER_ERROR);
  3108.                     return NGX_DONE;
  3109.                 }
  3110.             }
  3111.         }

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

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

  3118.         } else {
  3119.             ngx_str_null(&args);
  3120.             flags = NGX_HTTP_LOG_UNSAFE;

  3122.             if (ngx_http_parse_unsafe_uri(r, &uri, &args, &flags) != NGX_OK) {
  3123.                 ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  3124.                 return NGX_DONE;
  3125.             }

  3127.             if (r->method != NGX_HTTP_HEAD) {
  3128.                 r->method = NGX_HTTP_GET;
  3129.                 r->method_name = ngx_http_core_get_method;
  3130.             }

  3132.             ngx_http_internal_redirect(r, &uri, &args);
  3133.         }

  3135.         ngx_http_finalize_request(r, NGX_DONE);
  3136.         return NGX_DONE;
  3137.     }

  3139.     part = &u->headers_in.headers.part;
  3140.     h = part->elts;

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

  3144.         if (i >= part->nelts) {
  3145.             if (part->next == NULL) {
  3146.                 break;
  3147.             }

  3149.             part = part->next;
  3150.             h = part->elts;
  3151.             i = 0;
  3152.         }

  3154.         if (h[i].hash == 0) {
  3155.             continue;
  3156.         }

  3158.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3159.                           h[i].lowcase_key, h[i].key.len))
  3160.         {
  3161.             continue;
  3162.         }

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

  3167.         if (hh) {
  3168.             if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  3169.                 ngx_http_upstream_finalize_request(r, u,
  3170.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  3171.                 return NGX_DONE;
  3172.             }

  3174.             continue;
  3175.         }

  3177.         if (ngx_http_upstream_copy_header_line(r, &h[i], 0) != NGX_OK) {
  3178.             ngx_http_upstream_finalize_request(r, u,
  3179.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  3180.             return NGX_DONE;
  3181.         }
  3182.     }

  3184.     if (r->headers_out.server && r->headers_out.server->value.data == NULL) {
  3185.         r->headers_out.server->hash = 0;
  3186.     }

  3188.     if (r->headers_out.date && r->headers_out.date->value.data == NULL) {
  3189.         r->headers_out.date->hash = 0;
  3190.     }

  3192.     r->headers_out.status = u->headers_in.status_n;
  3193.     r->headers_out.status_line = u->headers_in.status_line;

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

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

  3199.     if (u->conf->force_ranges) {
  3200.         r->allow_ranges = 1;
  3201.         r->single_range = 1;

  3203. #if (NGX_HTTP_CACHE)
  3204.         if (r->cached) {
  3205.             r->single_range = 0;
  3206.         }
  3207. #endif
  3208.     }

  3210.     u->length = -1;

  3212.     return NGX_OK;
  3213. }


  3216. static ngx_int_t
  3217. ‌ngx_http_upstream_process_trailers(ngx_http_request_t *r,
  3218.     ngx_http_upstream_t *u)
  3219. {
  3220.     ngx_uint_t        i;
  3221.     ngx_list_part_t  *part;
  3222.     ngx_table_elt_t  *h, *ho;

  3224.     if (!u->conf->pass_trailers) {
  3225.         return NGX_OK;
  3226.     }

  3228.     part = &u->headers_in.trailers.part;
  3229.     h = part->elts;

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

  3233.         if (i >= part->nelts) {
  3234.             if (part->next == NULL) {
  3235.                 break;
  3236.             }

  3238.             part = part->next;
  3239.             h = part->elts;
  3240.             i = 0;
  3241.         }

  3243.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3244.                           h[i].lowcase_key, h[i].key.len))
  3245.         {
  3246.             continue;
  3247.         }

  3249.         ho = ngx_list_push(&r->headers_out.trailers);
  3250.         if (ho == NULL) {
  3251.             return NGX_ERROR;
  3252.         }

  3254.         *ho = h[i];
  3255.     }

  3257.     return NGX_OK;
  3258. }


  3261. static void
  3262. ‌ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3263. {
  3264.     ssize_t                    n;
  3265.     ngx_int_t                  rc;
  3266.     ngx_event_pipe_t          *p;
  3267.     ngx_connection_t          *c;
  3268.     ngx_http_core_loc_conf_t  *clcf;

  3270.     rc = ngx_http_send_header(r);

  3272.     if (rc == NGX_ERROR || rc > NGX_OK || r->post_action) {
  3273.         ngx_http_upstream_finalize_request(r, u, rc);
  3274.         return;
  3275.     }

  3277.     u->header_sent = 1;

  3279.     if (u->upgrade) {

  3281. #if (NGX_HTTP_CACHE)

  3283.         if (r->cache) {
  3284.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3285.         }

  3287. #endif

  3289.         ngx_http_upstream_upgrade(r, u);
  3290.         return;
  3291.     }

  3293.     c = r->connection;

  3295.     if (r->header_only) {

  3297.         if (!u->buffering) {
  3298.             ngx_http_upstream_finalize_request(r, u, rc);
  3299.             return;
  3300.         }

  3302.         if (!u->cacheable && !u->store) {
  3303.             ngx_http_upstream_finalize_request(r, u, rc);
  3304.             return;
  3305.         }

  3307.         u->pipe->downstream_error = 1;
  3308.     }

  3310.     if (r->request_body && r->request_body->temp_file
  3311.         && r == r->main && !r->preserve_body
  3312.         && !u->conf->preserve_output)
  3313.     {
  3314.         ngx_pool_run_cleanup_file(r->pool, r->request_body->temp_file->file.fd);
  3315.         r->request_body->temp_file->file.fd = NGX_INVALID_FILE;
  3316.     }

  3318.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3320.     if (!u->buffering) {

  3322. #if (NGX_HTTP_CACHE)

  3324.         if (r->cache) {
  3325.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3326.         }

  3328. #endif

  3330.         if (u->input_filter == NULL) {
  3331.             u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
  3332.             u->input_filter = ngx_http_upstream_non_buffered_filter;
  3333.             u->input_filter_ctx = r;
  3334.         }

  3336.         u->read_event_handler = ngx_http_upstream_process_non_buffered_upstream;
  3337.         r->write_event_handler =
  3338.                              ngx_http_upstream_process_non_buffered_downstream;

  3340.         r->limit_rate = 0;
  3341.         r->limit_rate_set = 1;

  3343.         if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
  3344.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3345.             return;
  3346.         }

  3348.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3349.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3350.             return;
  3351.         }

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

  3355.         if (n) {
  3356.             u->buffer.last = u->buffer.pos;

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

  3360.             if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  3361.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3362.                 return;
  3363.             }

  3365.             ngx_http_upstream_process_non_buffered_downstream(r);

  3367.         } else {
  3368.             u->buffer.pos = u->buffer.start;
  3369.             u->buffer.last = u->buffer.start;

  3371.             if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3372.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3373.                 return;
  3374.             }

  3376.             ngx_http_upstream_process_non_buffered_upstream(r, u);
  3377.         }

  3379.         return;
  3380.     }

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

  3384. #if (NGX_HTTP_CACHE)

  3386.     if (r->cache && r->cache->file.fd != NGX_INVALID_FILE) {
  3387.         ngx_pool_run_cleanup_file(r->pool, r->cache->file.fd);
  3388.         r->cache->file.fd = NGX_INVALID_FILE;
  3389.     }

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

  3393.     case NGX_ERROR:
  3394.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3395.         return;

  3397.     case NGX_DECLINED:
  3398.         u->cacheable = 0;
  3399.         break;

  3401.     default: /* NGX_OK */

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

  3405.             /* create cache if previously bypassed */

  3407.             if (ngx_http_file_cache_create(r) != NGX_OK) {
  3408.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3409.                 return;
  3410.             }
  3411.         }

  3413.         break;
  3414.     }

  3416.     if (u->cacheable) {
  3417.         time_t  now, valid;

  3419.         now = ngx_time();

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

  3423.         if (valid == 0) {
  3424.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  3425.                                               u->headers_in.status_n);
  3426.             if (valid) {
  3427.                 r->cache->valid_sec = now + valid;
  3428.             }
  3429.         }

  3431.         if (valid) {
  3432.             r->cache->date = now;
  3433.             r->cache->body_start = (u_short) (u->buffer.pos - u->buffer.start);

  3435.             if (u->headers_in.status_n == NGX_HTTP_OK
  3436.                 || u->headers_in.status_n == NGX_HTTP_PARTIAL_CONTENT)
  3437.             {
  3438.                 r->cache->last_modified = u->headers_in.last_modified_time;

  3440.                 if (u->headers_in.etag) {
  3441.                     r->cache->etag = u->headers_in.etag->value;

  3443.                 } else {
  3444.                     ngx_str_null(&r->cache->etag);
  3445.                 }

  3447.             } else {
  3448.                 r->cache->last_modified = -1;
  3449.                 ngx_str_null(&r->cache->etag);
  3450.             }

  3452.             if (ngx_http_file_cache_set_header(r, u->buffer.start) != NGX_OK) {
  3453.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3454.                 return;
  3455.             }

  3457.         } else {
  3458.             u->cacheable = 0;
  3459.         }
  3460.     }

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

  3465.     if (u->cacheable == 0 && r->cache) {
  3466.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3467.     }

  3469.     if (r->header_only && !u->cacheable && !u->store) {
  3470.         ngx_http_upstream_finalize_request(r, u, 0);
  3471.         return;
  3472.     }

  3474. #endif

  3476.     p = u->pipe;

  3478.     p->output_filter = ngx_http_upstream_output_filter;
  3479.     p->output_ctx = r;
  3480.     p->tag = u->output.tag;
  3481.     p->bufs = u->conf->bufs;
  3482.     p->busy_size = u->conf->busy_buffers_size;
  3483.     p->upstream = u->peer.connection;
  3484.     p->downstream = c;
  3485.     p->pool = r->pool;
  3486.     p->log = c->log;
  3487.     p->limit_rate = ngx_http_complex_value_size(r, u->conf->limit_rate, 0);
  3488.     p->start_sec = ngx_time();

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

  3492.     p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  3493.     if (p->temp_file == NULL) {
  3494.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3495.         return;
  3496.     }

  3498.     p->temp_file->file.fd = NGX_INVALID_FILE;
  3499.     p->temp_file->file.log = c->log;
  3500.     p->temp_file->path = u->conf->temp_path;
  3501.     p->temp_file->pool = r->pool;

  3503.     if (p->cacheable) {
  3504.         p->temp_file->persistent = 1;

  3506. #if (NGX_HTTP_CACHE)
  3507.         if (r->cache && !r->cache->file_cache->use_temp_path) {
  3508.             p->temp_file->path = r->cache->file_cache->path;
  3509.             p->temp_file->file.name = r->cache->file.name;
  3510.         }
  3511. #endif

  3513.     } else {
  3514.         p->temp_file->log_level = NGX_LOG_WARN;
  3515.         p->temp_file->warn = "an upstream response is buffered "
  3516.                              "to a temporary file";
  3517.     }

  3519.     p->max_temp_file_size = u->conf->max_temp_file_size;
  3520.     p->temp_file_write_size = u->conf->temp_file_write_size;

  3522. #if (NGX_THREADS)
  3523.     if (clcf->aio == NGX_HTTP_AIO_THREADS && clcf->aio_write) {
  3524.         p->thread_handler = ngx_http_upstream_thread_handler;
  3525.         p->thread_ctx = r;
  3526.     }
  3527. #endif

  3529.     p->preread_bufs = ngx_alloc_chain_link(r->pool);
  3530.     if (p->preread_bufs == NULL) {
  3531.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3532.         return;
  3533.     }

  3535.     p->preread_bufs->buf = &u->buffer;
  3536.     p->preread_bufs->next = NULL;
  3537.     u->buffer.recycled = 1;

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

  3541.     if (u->cacheable) {

  3543.         p->buf_to_file = ngx_calloc_buf(r->pool);
  3544.         if (p->buf_to_file == NULL) {
  3545.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3546.             return;
  3547.         }

  3549.         p->buf_to_file->start = u->buffer.start;
  3550.         p->buf_to_file->pos = u->buffer.start;
  3551.         p->buf_to_file->last = u->buffer.pos;
  3552.         p->buf_to_file->temporary = 1;
  3553.     }

  3555.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  3556.         /* the posted aio operation may corrupt a shadow buffer */
  3557.         p->single_buf = 1;
  3558.     }

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

  3563.     /*
  3564.      * event_pipe would do u->buffer.last += p->preread_size
  3565.      * as though these bytes were read
  3566.      */
  3567.     u->buffer.last = u->buffer.pos;

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

  3571.         /*
  3572.          * we need to disable the use of sendfile() if we use cyclic temp file
  3573.          * because the writing a new data may interfere with sendfile()
  3574.          * that uses the same kernel file pages (at least on FreeBSD)
  3575.          */

  3577.         p->cyclic_temp_file = 1;
  3578.         c->sendfile = 0;

  3580.     } else {
  3581.         p->cyclic_temp_file = 0;
  3582.     }

  3584.     p->read_timeout = u->conf->read_timeout;
  3585.     p->send_timeout = clcf->send_timeout;
  3586.     p->send_lowat = clcf->send_lowat;

  3588.     p->length = -1;

  3590.     if (u->input_filter_init
  3591.         && u->input_filter_init(p->input_ctx) != NGX_OK)
  3592.     {
  3593.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3594.         return;
  3595.     }

  3597.     u->read_event_handler = ngx_http_upstream_process_upstream;
  3598.     r->write_event_handler = ngx_http_upstream_process_downstream;

  3600.     ngx_http_upstream_process_upstream(r, u);
  3601. }


  3604. static void
  3605. ‌ngx_http_upstream_upgrade(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3606. {
  3607.     ngx_connection_t          *c;
  3608.     ngx_http_core_loc_conf_t  *clcf;

  3610.     c = r->connection;
  3611.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  3615.     if (r != r->main) {
  3616.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  3617.                       "connection upgrade in subrequest");
  3618.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3619.         return;
  3620.     }

  3622.     r->keepalive = 0;
  3623.     c->log->action = "proxying upgraded connection";

  3625.     u->read_event_handler = ngx_http_upstream_upgraded_read_upstream;
  3626.     u->write_event_handler = ngx_http_upstream_upgraded_write_upstream;
  3627.     r->read_event_handler = ngx_http_upstream_upgraded_read_downstream;
  3628.     r->write_event_handler = ngx_http_upstream_upgraded_write_downstream;

  3630.     if (clcf->tcp_nodelay) {

  3632.         if (ngx_tcp_nodelay(c) != NGX_OK) {
  3633.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3634.             return;
  3635.         }

  3637.         if (ngx_tcp_nodelay(u->peer.connection) != NGX_OK) {
  3638.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3639.             return;
  3640.         }
  3641.     }

  3643.     if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3644.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3645.         return;
  3646.     }

  3648.     if (u->peer.connection->read->ready
  3649.         || u->buffer.pos != u->buffer.last)
  3650.     {
  3651.         ngx_post_event(c->read, &ngx_posted_events);
  3652.         ngx_http_upstream_process_upgraded(r, 1, 1);
  3653.         return;
  3654.     }

  3656.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3657. }


  3660. static void
  3661. ‌ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r)
  3662. {
  3663.     ngx_http_upstream_process_upgraded(r, 0, 0);
  3664. }


  3667. static void
  3668. ‌ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r)
  3669. {
  3670.     ngx_http_upstream_process_upgraded(r, 1, 1);
  3671. }


  3674. static void
  3675. ‌ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  3676.     ngx_http_upstream_t *u)
  3677. {
  3678.     ngx_http_upstream_process_upgraded(r, 1, 0);
  3679. }


  3682. static void
  3683. ‌ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  3684.     ngx_http_upstream_t *u)
  3685. {
  3686.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3687. }


  3690. static void
  3691. ‌ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  3692.     ngx_uint_t from_upstream, ngx_uint_t do_write)
  3693. {
  3694.     size_t                     size;
  3695.     ssize_t                    n;
  3696.     ngx_buf_t                 *b;
  3697.     ngx_uint_t                 flags;
  3698.     ngx_connection_t          *c, *downstream, *upstream, *dst, *src;
  3699.     ngx_http_upstream_t       *u;
  3700.     ngx_http_core_loc_conf_t  *clcf;

  3702.     c = r->connection;
  3703.     u = r->upstream;

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

  3708.     downstream = c;
  3709.     upstream = u->peer.connection;

  3711.     if (downstream->write->timedout) {
  3712.         c->timedout = 1;
  3713.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3714.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3715.         return;
  3716.     }

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

  3724.     if (from_upstream) {
  3725.         src = upstream;
  3726.         dst = downstream;
  3727.         b = &u->buffer;

  3729.     } else {
  3730.         src = downstream;
  3731.         dst = upstream;
  3732.         b = &u->from_client;

  3734.         if (r->header_in->last > r->header_in->pos) {
  3735.             b = r->header_in;
  3736.             b->end = b->last;
  3737.             do_write = 1;
  3738.         }

  3740.         if (b->start == NULL) {
  3741.             b->start = ngx_palloc(r->pool, u->conf->buffer_size);
  3742.             if (b->start == NULL) {
  3743.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3744.                 return;
  3745.             }

  3747.             b->pos = b->start;
  3748.             b->last = b->start;
  3749.             b->end = b->start + u->conf->buffer_size;
  3750.             b->temporary = 1;
  3751.             b->tag = u->output.tag;
  3752.         }
  3753.     }

  3755.     for ( ;; ) {

  3757.         if (do_write) {

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

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

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

  3765.                 if (n == NGX_ERROR) {
  3766.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3767.                     return;
  3768.                 }

  3770.                 if (n > 0) {
  3771.                     b->pos += n;

  3773.                     if (b->pos == b->last) {
  3774.                         b->pos = b->start;
  3775.                         b->last = b->start;
  3776.                     }
  3777.                 }
  3778.             }
  3779.         }

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

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

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

  3787.             if (n == NGX_AGAIN || n == 0) {
  3788.                 break;
  3789.             }

  3791.             if (n > 0) {
  3792.                 do_write = 1;
  3793.                 b->last += n;

  3795.                 if (from_upstream) {
  3796.                     u->state->bytes_received += n;
  3797.                 }

  3799.                 continue;
  3800.             }

  3802.             if (n == NGX_ERROR) {
  3803.                 src->read->eof = 1;
  3804.             }
  3805.         }

  3807.         break;
  3808.     }

  3810.     if ((upstream->read->eof && u->buffer.pos == u->buffer.last)
  3811.         || (downstream->read->eof && u->from_client.pos == u->from_client.last)
  3812.         || (downstream->read->eof && upstream->read->eof))
  3813.     {
  3814.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3815.                        "http upstream upgraded done");
  3816.         ngx_http_upstream_finalize_request(r, u, 0);
  3817.         return;
  3818.     }

  3820.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3822.     if (ngx_handle_write_event(upstream->write, u->conf->send_lowat)
  3823.         != NGX_OK)
  3824.     {
  3825.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3826.         return;
  3827.     }

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

  3832.     } else if (upstream->write->timer_set) {
  3833.         ngx_del_timer(upstream->write);
  3834.     }

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

  3839.     } else {
  3840.         flags = 0;
  3841.     }

  3843.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  3844.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3845.         return;
  3846.     }

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

  3851.     } else if (upstream->read->timer_set) {
  3852.         ngx_del_timer(upstream->read);
  3853.     }

  3855.     if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3856.         != NGX_OK)
  3857.     {
  3858.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3859.         return;
  3860.     }

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

  3865.     } else {
  3866.         flags = 0;
  3867.     }

  3869.     if (ngx_handle_read_event(downstream->read, flags) != NGX_OK) {
  3870.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3871.         return;
  3872.     }

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

  3877.     } else if (downstream->write->timer_set) {
  3878.         ngx_del_timer(downstream->write);
  3879.     }
  3880. }


  3883. static void
  3884. ‌ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r)
  3885. {
  3886.     ngx_event_t          *wev;
  3887.     ngx_connection_t     *c;
  3888.     ngx_http_upstream_t  *u;

  3890.     c = r->connection;
  3891.     u = r->upstream;
  3892.     wev = c->write;

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

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

  3899.     if (wev->timedout) {
  3900.         c->timedout = 1;
  3901.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3902.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3903.         return;
  3904.     }

  3906.     ngx_http_upstream_process_non_buffered_request(r, 1);
  3907. }


  3910. static void
  3911. ‌ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  3912.     ngx_http_upstream_t *u)
  3913. {
  3914.     ngx_connection_t  *c;

  3916.     c = u->peer.connection;

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

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

  3923.     if (c->read->timedout) {
  3924.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3925.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3926.         return;
  3927.     }

  3929.     ngx_http_upstream_process_non_buffered_request(r, 0);
  3930. }


  3933. static void
  3934. ‌ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  3935.     ngx_uint_t do_write)
  3936. {
  3937.     size_t                     size;
  3938.     ssize_t                    n;
  3939.     ngx_buf_t                 *b;
  3940.     ngx_int_t                  rc;
  3941.     ngx_uint_t                 flags;
  3942.     ngx_connection_t          *downstream, *upstream;
  3943.     ngx_http_upstream_t       *u;
  3944.     ngx_http_core_loc_conf_t  *clcf;

  3946.     u = r->upstream;
  3947.     downstream = r->connection;
  3948.     upstream = u->peer.connection;

  3950.     b = &u->buffer;

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

  3954.     for ( ;; ) {

  3956.         if (do_write) {

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

  3961.                 if (rc == NGX_ERROR) {
  3962.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3963.                     return;
  3964.                 }

  3966.                 ngx_chain_update_chains(r->pool, &u->free_bufs, &u->busy_bufs,
  3967.                                         &u->out_bufs, u->output.tag);
  3968.             }

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

  3972.                 if (u->length == 0
  3973.                     || (upstream->read->eof && u->length == -1))
  3974.                 {
  3975.                     ngx_http_upstream_finalize_request(r, u, 0);
  3976.                     return;
  3977.                 }

  3979.                 if (upstream->read->eof) {
  3980.                     ngx_log_error(NGX_LOG_ERR, upstream->log, 0,
  3981.                                   "upstream prematurely closed connection");

  3983.                     ngx_http_upstream_finalize_request(r, u,
  3984.                                                        NGX_HTTP_BAD_GATEWAY);
  3985.                     return;
  3986.                 }

  3988.                 if (upstream->read->error || u->error) {
  3989.                     ngx_http_upstream_finalize_request(r, u,
  3990.                                                        NGX_HTTP_BAD_GATEWAY);
  3991.                     return;
  3992.                 }

  3994.                 b->pos = b->start;
  3995.                 b->last = b->start;
  3996.             }
  3997.         }

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

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

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

  4005.             if (n == NGX_AGAIN) {
  4006.                 break;
  4007.             }

  4009.             if (n > 0) {
  4010.                 u->state->bytes_received += n;
  4011.                 u->state->response_length += n;

  4013.                 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  4014.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4015.                     return;
  4016.                 }
  4017.             }

  4019.             do_write = 1;

  4021.             continue;
  4022.         }

  4024.         break;
  4025.     }

  4027.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4029.     if (downstream->data == r) {
  4030.         if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  4031.             != NGX_OK)
  4032.         {
  4033.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4034.             return;
  4035.         }
  4036.     }

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

  4041.     } else if (downstream->write->timer_set) {
  4042.         ngx_del_timer(downstream->write);
  4043.     }

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

  4048.     } else {
  4049.         flags = 0;
  4050.     }

  4052.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  4053.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4054.         return;
  4055.     }

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

  4060.     } else if (upstream->read->timer_set) {
  4061.         ngx_del_timer(upstream->read);
  4062.     }
  4063. }


  4066. ngx_int_t
  4067. ‌ngx_http_upstream_non_buffered_filter_init(void *data)
  4068. {
  4069.     return NGX_OK;
  4070. }


  4073. ngx_int_t
  4074. ‌ngx_http_upstream_non_buffered_filter(void *data, ssize_t bytes)
  4075. {
  4076.     ngx_http_request_t  *r = data;

  4078.     ngx_buf_t            *b;
  4079.     ngx_chain_t          *cl, **ll;
  4080.     ngx_http_upstream_t  *u;

  4082.     u = r->upstream;

  4084.     if (u->length == 0) {
  4085.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4086.                       "upstream sent more data than specified in "
  4087.                       "\"Content-Length\" header");
  4088.         return NGX_OK;
  4089.     }

  4091.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  4092.         ll = &cl->next;
  4093.     }

  4095.     cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  4096.     if (cl == NULL) {
  4097.         return NGX_ERROR;
  4098.     }

  4100.     *ll = cl;

  4102.     cl->buf->flush = 1;
  4103.     cl->buf->memory = 1;

  4105.     b = &u->buffer;

  4107.     cl->buf->pos = b->last;
  4108.     b->last += bytes;
  4109.     cl->buf->last = b->last;
  4110.     cl->buf->tag = u->output.tag;

  4112.     if (u->length == -1) {
  4113.         return NGX_OK;
  4114.     }

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

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

  4122.         cl->buf->last = cl->buf->pos + u->length;
  4123.         u->length = 0;

  4125.         return NGX_OK;
  4126.     }

  4128.     u->length -= bytes;

  4130.     return NGX_OK;
  4131. }


  4134. #if (NGX_THREADS)

  4136. static ngx_int_t
  4137. ‌ngx_http_upstream_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
  4138. {
  4139.     ngx_str_t                  name;
  4140.     ngx_event_pipe_t          *p;
  4141.     ngx_connection_t          *c;
  4142.     ngx_thread_pool_t         *tp;
  4143.     ngx_http_request_t        *r;
  4144.     ngx_http_core_loc_conf_t  *clcf;

  4146.     r = file->thread_ctx;
  4147.     p = r->upstream->pipe;

  4149.     if (r->aio) {
  4150.         /*
  4151.          * tolerate sendfile() calls if another operation is already
  4152.          * running; this can happen due to subrequests, multiple calls
  4153.          * of the next body filter from a filter, or in HTTP/2 due to
  4154.          * a write event on the main connection
  4155.          */

  4157.         c = r->connection;

  4159. #if (NGX_HTTP_V2)
  4160.         if (r->stream) {
  4161.             c = r->stream->connection->connection;
  4162.         }
  4163. #endif

  4165.         if (task == c->sendfile_task) {
  4166.             return NGX_OK;
  4167.         }
  4168.     }

  4170.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4171.     tp = clcf->thread_pool;

  4173.     if (tp == NULL) {
  4174.         if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
  4175.             != NGX_OK)
  4176.         {
  4177.             return NGX_ERROR;
  4178.         }

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

  4182.         if (tp == NULL) {
  4183.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4184.                           "thread pool \"%V\" not found", &name);
  4185.             return NGX_ERROR;
  4186.         }
  4187.     }

  4189.     task->event.data = r;
  4190.     task->event.handler = ngx_http_upstream_thread_event_handler;

  4192.     if (ngx_thread_task_post(tp, task) != NGX_OK) {
  4193.         return NGX_ERROR;
  4194.     }

  4196.     r->main->blocked++;
  4197.     r->aio = 1;
  4198.     p->aio = 1;

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

  4202.     return NGX_OK;
  4203. }


  4206. static void
  4207. ‌ngx_http_upstream_thread_event_handler(ngx_event_t *ev)
  4208. {
  4209.     ngx_connection_t    *c;
  4210.     ngx_http_request_t  *r;

  4212.     r = ev->data;
  4213.     c = r->connection;

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

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

  4220.     if (ev->timedout) {
  4221.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  4222.                       "thread operation took too long");
  4223.         ev->timedout = 0;
  4224.         return;
  4225.     }

  4227.     if (ev->timer_set) {
  4228.         ngx_del_timer(ev);
  4229.     }

  4231.     r->main->blocked--;
  4232.     r->aio = 0;

  4234. #if (NGX_HTTP_V2)

  4236.     if (r->stream) {
  4237.         /*
  4238.          * for HTTP/2, update write event to make sure processing will
  4239.          * reach the main connection to handle sendfile() in threads
  4240.          */

  4242.         c->write->ready = 1;
  4243.         c->write->active = 0;
  4244.     }

  4246. #endif

  4248.     if (r->done || r->main->terminated) {
  4249.         /*
  4250.          * trigger connection event handler if the subrequest was
  4251.          * already finalized (this can happen if the handler is used
  4252.          * for sendfile() in threads), or if the request was terminated
  4253.          */

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

  4257.     } else {
  4258.         r->write_event_handler(r);
  4259.         ngx_http_run_posted_requests(c);
  4260.     }
  4261. }

  4263. #endif


  4266. static ngx_int_t
  4267. ‌ngx_http_upstream_output_filter(void *data, ngx_chain_t *chain)
  4268. {
  4269.     ngx_int_t            rc;
  4270.     ngx_event_pipe_t    *p;
  4271.     ngx_http_request_t  *r;

  4273.     r = data;
  4274.     p = r->upstream->pipe;

  4276.     rc = ngx_http_output_filter(r, chain);

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

  4280.     return rc;
  4281. }


  4284. static void
  4285. ‌ngx_http_upstream_process_downstream(ngx_http_request_t *r)
  4286. {
  4287.     ngx_event_t          *wev;
  4288.     ngx_connection_t     *c;
  4289.     ngx_event_pipe_t     *p;
  4290.     ngx_http_upstream_t  *u;

  4292.     c = r->connection;
  4293.     u = r->upstream;
  4294.     p = u->pipe;
  4295.     wev = c->write;

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

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

  4302. #if (NGX_THREADS)
  4303.     p->aio = r->aio;
  4304. #endif

  4306.     if (wev->timedout) {

  4308.         p->downstream_error = 1;
  4309.         c->timedout = 1;
  4310.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");

  4312.     } else {

  4314.         if (wev->delayed) {

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

  4319.             if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
  4320.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4321.             }

  4323.             return;
  4324.         }

  4326.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4327.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4328.             return;
  4329.         }
  4330.     }

  4332.     ngx_http_upstream_process_request(r, u);
  4333. }


  4336. static void
  4337. ‌ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  4338.     ngx_http_upstream_t *u)
  4339. {
  4340.     ngx_event_t       *rev;
  4341.     ngx_event_pipe_t  *p;
  4342.     ngx_connection_t  *c;

  4344.     c = u->peer.connection;
  4345.     p = u->pipe;
  4346.     rev = c->read;

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

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

  4353.     if (rev->timedout) {

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

  4358.     } else {

  4360.         if (rev->delayed) {

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

  4365.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  4366.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4367.             }

  4369.             return;
  4370.         }

  4372.         if (ngx_event_pipe(p, 0) == NGX_ABORT) {
  4373.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4374.             return;
  4375.         }
  4376.     }

  4378.     ngx_http_upstream_process_request(r, u);
  4379. }


  4382. static void
  4383. ‌ngx_http_upstream_process_request(ngx_http_request_t *r,
  4384.     ngx_http_upstream_t *u)
  4385. {
  4386.     ngx_temp_file_t   *tf;
  4387.     ngx_event_pipe_t  *p;

  4389.     p = u->pipe;

  4391. #if (NGX_THREADS)

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

  4395.         /*
  4396.          * make sure to call ngx_event_pipe()
  4397.          * if there is an incomplete aio write
  4398.          */

  4400.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4401.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4402.             return;
  4403.         }
  4404.     }

  4406.     if (p->writing) {
  4407.         return;
  4408.     }

  4410. #endif

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

  4414.         if (u->store) {

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

  4418.                 tf = p->temp_file;

  4420.                 if (u->headers_in.status_n == NGX_HTTP_OK
  4421.                     && (p->upstream_done || p->length == -1)
  4422.                     && (u->headers_in.content_length_n == -1
  4423.                         || u->headers_in.content_length_n == tf->offset))
  4424.                 {
  4425.                     ngx_http_upstream_store(r, u);
  4426.                 }
  4427.             }
  4428.         }

  4430. #if (NGX_HTTP_CACHE)

  4432.         if (u->cacheable) {

  4434.             if (p->upstream_done) {
  4435.                 ngx_http_file_cache_update(r, p->temp_file);

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

  4439.                 tf = p->temp_file;

  4441.                 if (p->length == -1
  4442.                     && (u->headers_in.content_length_n == -1
  4443.                         || u->headers_in.content_length_n
  4444.                            == tf->offset - (off_t) r->cache->body_start))
  4445.                 {
  4446.                     ngx_http_file_cache_update(r, tf);

  4448.                 } else {
  4449.                     ngx_http_file_cache_free(r->cache, tf);
  4450.                 }

  4452.             } else if (p->upstream_error) {
  4453.                 ngx_http_file_cache_free(r->cache, p->temp_file);
  4454.             }
  4455.         }

  4457. #endif

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

  4463.             if (p->upstream_done
  4464.                 || (p->upstream_eof && p->length == -1))
  4465.             {
  4466.                 ngx_http_upstream_finalize_request(r, u, 0);
  4467.                 return;
  4468.             }

  4470.             if (p->upstream_eof) {
  4471.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4472.                               "upstream prematurely closed connection");
  4473.             }

  4475.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  4476.             return;
  4477.         }
  4478.     }

  4480.     if (p->downstream_error) {
  4481.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4482.                        "http upstream downstream error");

  4484.         if (!u->cacheable && !u->store && u->peer.connection) {
  4485.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4486.         }
  4487.     }
  4488. }


  4491. static void
  4492. ‌ngx_http_upstream_store(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4493. {
  4494.     size_t                  root;
  4495.     time_t                  lm;
  4496.     ngx_str_t               path;
  4497.     ngx_temp_file_t        *tf;
  4498.     ngx_ext_rename_file_t   ext;

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

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

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

  4506.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  4507.         if (tf == NULL) {
  4508.             return;
  4509.         }

  4511.         tf->file.fd = NGX_INVALID_FILE;
  4512.         tf->file.log = r->connection->log;
  4513.         tf->path = u->conf->temp_path;
  4514.         tf->pool = r->pool;
  4515.         tf->persistent = 1;

  4517.         if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  4518.                                  tf->persistent, tf->clean, tf->access)
  4519.             != NGX_OK)
  4520.         {
  4521.             return;
  4522.         }

  4524.         u->pipe->temp_file = tf;
  4525.     }

  4527.     ext.access = u->conf->store_access;
  4528.     ext.path_access = u->conf->store_access;
  4529.     ext.time = -1;
  4530.     ext.create_path = 1;
  4531.     ext.delete_file = 1;
  4532.     ext.log = r->connection->log;

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

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

  4539.         if (lm != NGX_ERROR) {
  4540.             ext.time = lm;
  4541.             ext.fd = tf->file.fd;
  4542.         }
  4543.     }

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

  4547.         if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  4548.             return;
  4549.         }

  4551.     } else {
  4552.         if (ngx_http_script_run(r, &path, u->conf->store_lengths->elts, 0,
  4553.                                 u->conf->store_values->elts)
  4554.             == NULL)
  4555.         {
  4556.             return;
  4557.         }
  4558.     }

  4560.     path.len--;

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

  4566.     if (path.len == 0) {
  4567.         return;
  4568.     }

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

  4572.     u->store = 0;
  4573. }


  4576. static void
  4577. ‌ngx_http_upstream_dummy_handler(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4578. {
  4579.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4580.                    "http upstream dummy handler");
  4581. }


  4584. static void
  4585. ‌ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
  4586.     ngx_uint_t ft_type)
  4587. {
  4588.     ngx_msec_t  timeout;
  4589.     ngx_uint_t  status, state;

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

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

  4596.         if (u->peer.connection) {
  4597.             u->state->bytes_sent = u->peer.connection->sent;
  4598.         }

  4600.         if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_403
  4601.             || ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404)
  4602.         {
  4603.             state = NGX_PEER_NEXT;

  4605.         } else {
  4606.             state = NGX_PEER_FAILED;
  4607.         }

  4609.         u->peer.free(&u->peer, u->peer.data, state);
  4610.         u->peer.sockaddr = NULL;

  4612. #if (NGX_HTTP_UPSTREAM_SID)
  4613.         u->peer.sid = NULL;
  4614. #endif
  4615.     }

  4617.     if (ft_type == NGX_HTTP_UPSTREAM_FT_TIMEOUT) {
  4618.         ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ETIMEDOUT,
  4619.                       "upstream timed out");
  4620.     }

  4622.     if (u->peer.cached && ft_type == NGX_HTTP_UPSTREAM_FT_ERROR) {
  4623.         /* TODO: inform balancer instead */
  4624.         u->peer.tries++;
  4625.     }

  4627.     switch (ft_type) {

  4629.     case NGX_HTTP_UPSTREAM_FT_TIMEOUT:
  4630.     case NGX_HTTP_UPSTREAM_FT_HTTP_504:
  4631.         status = NGX_HTTP_GATEWAY_TIME_OUT;
  4632.         break;

  4634.     case NGX_HTTP_UPSTREAM_FT_HTTP_500:
  4635.         status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4636.         break;

  4638.     case NGX_HTTP_UPSTREAM_FT_HTTP_503:
  4639.         status = NGX_HTTP_SERVICE_UNAVAILABLE;
  4640.         break;

  4642.     case NGX_HTTP_UPSTREAM_FT_HTTP_403:
  4643.         status = NGX_HTTP_FORBIDDEN;
  4644.         break;

  4646.     case NGX_HTTP_UPSTREAM_FT_HTTP_404:
  4647.         status = NGX_HTTP_NOT_FOUND;
  4648.         break;

  4650.     case NGX_HTTP_UPSTREAM_FT_HTTP_429:
  4651.         status = NGX_HTTP_TOO_MANY_REQUESTS;
  4652.         break;

  4654.     /*
  4655.      * NGX_HTTP_UPSTREAM_FT_BUSY_LOCK and NGX_HTTP_UPSTREAM_FT_MAX_WAITING
  4656.      * never reach here
  4657.      */

  4659.     default:
  4660.         status = NGX_HTTP_BAD_GATEWAY;
  4661.     }

  4663.     if (r->connection->error) {
  4664.         ngx_http_upstream_finalize_request(r, u,
  4665.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4666.         return;
  4667.     }

  4669.     u->state->status = status;

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

  4673.     if (u->request_sent
  4674.         && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  4675.     {
  4676.         ft_type |= NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;
  4677.     }

  4679.     if (u->peer.tries == 0
  4680.         || ((u->conf->next_upstream & ft_type) != ft_type)
  4681.         || (u->request_sent && r->request_body_no_buffering)
  4682.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  4683.     {
  4684. #if (NGX_HTTP_CACHE)

  4686.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  4687.             && ((u->conf->cache_use_stale & ft_type) || r->cache->stale_error))
  4688.         {
  4689.             ngx_int_t  rc;

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

  4693.             if (rc != NGX_OK) {
  4694.                 ngx_http_upstream_finalize_request(r, u, rc);
  4695.                 return;
  4696.             }

  4698.             u->cache_status = NGX_HTTP_CACHE_STALE;
  4699.             rc = ngx_http_upstream_cache_send(r, u);

  4701.             if (rc == NGX_DONE) {
  4702.                 return;
  4703.             }

  4705.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  4706.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4707.             }

  4709.             ngx_http_upstream_finalize_request(r, u, rc);
  4710.             return;
  4711.         }
  4712. #endif

  4714.         ngx_http_upstream_finalize_request(r, u, status);
  4715.         return;
  4716.     }

  4718.     if (u->peer.connection) {
  4719.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4720.                        "close http upstream connection: %d",
  4721.                        u->peer.connection->fd);
  4722. #if (NGX_HTTP_SSL)

  4724.         if (u->peer.connection->ssl) {
  4725.             u->peer.connection->ssl->no_wait_shutdown = 1;
  4726.             u->peer.connection->ssl->no_send_shutdown = 1;

  4728.             (void) ngx_ssl_shutdown(u->peer.connection);
  4729.         }
  4730. #endif

  4732.         if (u->peer.connection->pool) {
  4733.             ngx_destroy_pool(u->peer.connection->pool);
  4734.         }

  4736.         ngx_close_connection(u->peer.connection);
  4737.         u->peer.connection = NULL;
  4738.     }

  4740.     ngx_http_upstream_connect(r, u);
  4741. }


  4744. static void
  4745. ‌ngx_http_upstream_cleanup(void *data)
  4746. {
  4747.     ngx_http_request_t *r = data;

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

  4752.     ngx_http_upstream_finalize_request(r, r->upstream, NGX_DONE);
  4753. }


  4756. static void
  4757. ‌ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  4758.     ngx_http_upstream_t *u, ngx_int_t rc)
  4759. {
  4760.     ngx_uint_t  flush;

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

  4765.     if (u->cleanup == NULL) {
  4766.         /* the request was already finalized */
  4767.         ngx_http_finalize_request(r, NGX_DONE);
  4768.         return;
  4769.     }

  4771.     *u->cleanup = NULL;
  4772.     u->cleanup = NULL;

  4774.     if (u->resolved && u->resolved->ctx) {
  4775.         ngx_resolve_name_done(u->resolved->ctx);
  4776.         u->resolved->ctx = NULL;
  4777.     }

  4779.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  4780.         u->state->response_time = ngx_current_msec - u->start_time;

  4782.         if (u->pipe && u->pipe->read_length) {
  4783.             u->state->bytes_received += u->pipe->read_length
  4784.                                         - u->pipe->preread_size;
  4785.             u->state->response_length = u->pipe->read_length;
  4786.         }

  4788.         if (u->peer.connection) {
  4789.             u->state->bytes_sent = u->peer.connection->sent;
  4790.         }
  4791.     }

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

  4795.     if (u->peer.free && u->peer.sockaddr) {
  4796.         u->peer.free(&u->peer, u->peer.data, 0);
  4797.         u->peer.sockaddr = NULL;

  4799. #if (NGX_HTTP_UPSTREAM_SID)
  4800.         u->peer.sid = NULL;
  4801. #endif
  4802.     }

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

  4806. #if (NGX_HTTP_SSL)

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

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

  4812.             /*
  4813.              * We send the "close notify" shutdown alert to the upstream only
  4814.              * and do not wait its "close notify" shutdown alert.
  4815.              * It is acceptable according to the TLS standard.
  4816.              */

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

  4820.             (void) ngx_ssl_shutdown(u->peer.connection);
  4821.         }
  4822. #endif

  4824.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4825.                        "close http upstream connection: %d",
  4826.                        u->peer.connection->fd);

  4828.         if (u->peer.connection->pool) {
  4829.             ngx_destroy_pool(u->peer.connection->pool);
  4830.         }

  4832.         ngx_close_connection(u->peer.connection);
  4833.     }

  4835.     u->peer.connection = NULL;

  4837.     if (u->pipe) {
  4838.         u->pipe->upstream = NULL;
  4839.     }

  4841.     if (u->pipe && u->pipe->temp_file) {
  4842.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4843.                        "http upstream temp fd: %d",
  4844.                        u->pipe->temp_file->file.fd);
  4845.     }

  4847.     if (u->store && u->pipe && u->pipe->temp_file
  4848.         && u->pipe->temp_file->file.fd != NGX_INVALID_FILE)
  4849.     {
  4850.         if (ngx_delete_file(u->pipe->temp_file->file.name.data)
  4851.             == NGX_FILE_ERROR)
  4852.         {
  4853.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  4854.                           ngx_delete_file_n " \"%s\" failed",
  4855.                           u->pipe->temp_file->file.name.data);
  4856.         }
  4857.     }

  4859. #if (NGX_HTTP_CACHE)

  4861.     if (r->cache) {

  4863.         if (u->cacheable) {

  4865.             if (rc == NGX_HTTP_BAD_GATEWAY || rc == NGX_HTTP_GATEWAY_TIME_OUT) {
  4866.                 time_t  valid;

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

  4870.                 if (valid) {
  4871.                     r->cache->valid_sec = ngx_time() + valid;
  4872.                     r->cache->error = rc;
  4873.                 }
  4874.             }
  4875.         }

  4877.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  4878.     }

  4880. #endif

  4882.     r->read_event_handler = ngx_http_block_reading;

  4884.     if (rc == NGX_DECLINED) {
  4885.         return;
  4886.     }

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

  4890.     if (!u->header_sent
  4891.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  4892.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST)
  4893.     {
  4894.         ngx_http_finalize_request(r, rc);
  4895.         return;
  4896.     }

  4898.     flush = 0;

  4900.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  4901.         rc = NGX_ERROR;
  4902.         flush = 1;
  4903.     }

  4905.     if (r->header_only
  4906.         || (u->pipe && u->pipe->downstream_error))
  4907.     {
  4908.         ngx_http_finalize_request(r, rc);
  4909.         return;
  4910.     }

  4912.     if (rc == 0) {

  4914.         if (ngx_http_upstream_process_trailers(r, u) != NGX_OK) {
  4915.             ngx_http_finalize_request(r, NGX_ERROR);
  4916.             return;
  4917.         }

  4919.         rc = ngx_http_send_special(r, NGX_HTTP_LAST);

  4921.     } else if (flush) {
  4922.         r->keepalive = 0;
  4923.         rc = ngx_http_send_special(r, NGX_HTTP_FLUSH);
  4924.     }

  4926.     ngx_http_finalize_request(r, rc);
  4927. }


  4930. static ngx_int_t
  4931. ‌ngx_http_upstream_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4932.     ngx_uint_t offset)
  4933. {
  4934.     ngx_table_elt_t  **ph;

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

  4938.     if (*ph) {
  4939.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4940.                       "upstream sent duplicate header line: \"%V: %V\", "
  4941.                       "previous value: \"%V: %V\", ignored",
  4942.                       &h->key, &h->value,
  4943.                       &(*ph)->key, &(*ph)->value);
  4944.         h->hash = 0;
  4945.         return NGX_OK;
  4946.     }

  4948.     *ph = h;
  4949.     h->next = NULL;

  4951.     return NGX_OK;
  4952. }


  4955. static ngx_int_t
  4956. ‌ngx_http_upstream_process_multi_header_lines(ngx_http_request_t *r,
  4957.     ngx_table_elt_t *h, ngx_uint_t offset)
  4958. {
  4959.     ngx_table_elt_t  **ph;

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

  4963.     while (*ph) { ph = &(*ph)->next; }

  4965.     *ph = h;
  4966.     h->next = NULL;

  4968.     return NGX_OK;
  4969. }


  4972. static ngx_int_t
  4973. ‌ngx_http_upstream_ignore_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4974.     ngx_uint_t offset)
  4975. {
  4976.     return NGX_OK;
  4977. }


  4980. static ngx_int_t
  4981. ‌ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  4982.     ngx_table_elt_t *h, ngx_uint_t offset)
  4983. {
  4984.     ngx_http_upstream_t  *u;

  4986.     u = r->upstream;

  4988.     if (u->headers_in.content_length) {
  4989.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4990.                       "upstream sent duplicate header line: \"%V: %V\", "
  4991.                       "previous value: \"%V: %V\"",
  4992.                       &h->key, &h->value,
  4993.                       &u->headers_in.content_length->key,
  4994.                       &u->headers_in.content_length->value);
  4995.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  4996.     }

  4998.     if (u->headers_in.transfer_encoding) {
  4999.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5000.                       "upstream sent \"Content-Length\" and "
  5001.                       "\"Transfer-Encoding\" headers at the same time");
  5002.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5003.     }

  5005.     h->next = NULL;
  5006.     u->headers_in.content_length = h;
  5007.     u->headers_in.content_length_n = ngx_atoof(h->value.data, h->value.len);

  5009.     if (u->headers_in.content_length_n == NGX_ERROR) {
  5010.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5011.                       "upstream sent invalid \"Content-Length\" header: "
  5012.                       "\"%V: %V\"", &h->key, &h->value);
  5013.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5014.     }

  5016.     return NGX_OK;
  5017. }


  5020. static ngx_int_t
  5021. ‌ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  5022.     ngx_table_elt_t *h, ngx_uint_t offset)
  5023. {
  5024.     ngx_http_upstream_t  *u;

  5026.     u = r->upstream;

  5028.     if (u->headers_in.last_modified) {
  5029.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5030.                       "upstream sent duplicate header line: \"%V: %V\", "
  5031.                       "previous value: \"%V: %V\", ignored",
  5032.                       &h->key, &h->value,
  5033.                       &u->headers_in.last_modified->key,
  5034.                       &u->headers_in.last_modified->value);
  5035.         h->hash = 0;
  5036.         return NGX_OK;
  5037.     }

  5039.     h->next = NULL;
  5040.     u->headers_in.last_modified = h;
  5041.     u->headers_in.last_modified_time = ngx_parse_http_time(h->value.data,
  5042.                                                            h->value.len);

  5044.     return NGX_OK;
  5045. }


  5048. static ngx_int_t
  5049. ‌ngx_http_upstream_process_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5050.     ngx_uint_t offset)
  5051. {
  5052.     ngx_table_elt_t      **ph;
  5053.     ngx_http_upstream_t   *u;

  5055.     u = r->upstream;
  5056.     ph = &u->headers_in.set_cookie;

  5058.     while (*ph) { ph = &(*ph)->next; }

  5060.     *ph = h;
  5061.     h->next = NULL;

  5063. #if (NGX_HTTP_CACHE)
  5064.     if (!(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_SET_COOKIE)) {
  5065.         u->cacheable = 0;
  5066.     }
  5067. #endif

  5069.     return NGX_OK;
  5070. }


  5073. static ngx_int_t
  5074. ‌ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  5075.     ngx_table_elt_t *h, ngx_uint_t offset)
  5076. {
  5077.     ngx_table_elt_t      **ph;
  5078.     ngx_http_upstream_t   *u;

  5080.     u = r->upstream;
  5081.     ph = &u->headers_in.cache_control;

  5083.     while (*ph) { ph = &(*ph)->next; }

  5085.     *ph = h;
  5086.     h->next = NULL;

  5088. #if (NGX_HTTP_CACHE)
  5089.     {
  5090.     u_char     *p, *start, *last;
  5091.     ngx_int_t   n;

  5093.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL) {
  5094.         return NGX_OK;
  5095.     }

  5097.     if (r->cache == NULL) {
  5098.         return NGX_OK;
  5099.     }

  5101.     start = h->value.data;
  5102.     last = start + h->value.len;

  5104.     if (r->cache->valid_sec != 0 && u->headers_in.x_accel_expires != NULL) {
  5105.         goto extensions;
  5106.     }

  5108.     if (ngx_strlcasestrn(start, last, (u_char *) "no-cache", 8 - 1) != NULL
  5109.         || ngx_strlcasestrn(start, last, (u_char *) "no-store", 8 - 1) != NULL
  5110.         || ngx_strlcasestrn(start, last, (u_char *) "private", 7 - 1) != NULL)
  5111.     {
  5112.         u->headers_in.no_cache = 1;
  5113.         return NGX_OK;
  5114.     }

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

  5119.     if (p == NULL) {
  5120.         p = ngx_strlcasestrn(start, last, (u_char *) "max-age=", 8 - 1);
  5121.         offset = 8;
  5122.     }

  5124.     if (p) {
  5125.         n = ngx_http_upstream_process_delta_seconds(p + offset, last);

  5127.         if (n == NGX_ERROR) {
  5128.             u->cacheable = 0;
  5129.             return NGX_OK;
  5130.         }

  5132.         if (n == 0) {
  5133.             u->headers_in.no_cache = 1;
  5134.             return NGX_OK;
  5135.         }

  5137.         r->cache->valid_sec = ngx_min((ngx_uint_t) ngx_time() + n,
  5138.                                       NGX_MAX_INT_T_VALUE);
  5139.         u->headers_in.expired = 0;
  5140.     }

  5142. extensions:

  5144.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-while-revalidate=",
  5145.                          23 - 1);

  5147.     if (p) {
  5148.         n = ngx_http_upstream_process_delta_seconds(p + 23, last);

  5150.         if (n == NGX_ERROR) {
  5151.             u->cacheable = 0;
  5152.             return NGX_OK;
  5153.         }

  5155.         r->cache->updating_sec = n;
  5156.         r->cache->error_sec = n;
  5157.     }

  5159.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-if-error=", 15 - 1);

  5161.     if (p) {
  5162.         n = ngx_http_upstream_process_delta_seconds(p + 15, last);

  5164.         if (n == NGX_ERROR) {
  5165.             u->cacheable = 0;
  5166.             return NGX_OK;
  5167.         }

  5169.         r->cache->error_sec = n;
  5170.     }
  5171.     }
  5172. #endif

  5174.     return NGX_OK;
  5175. }


  5178. #if (NGX_HTTP_CACHE)

  5180. static ngx_int_t
  5181. ‌ngx_http_upstream_process_delta_seconds(u_char *p, u_char *last)
  5182. {
  5183.     ngx_int_t  n, cutoff, cutlim;

  5185.     cutoff = NGX_MAX_INT_T_VALUE / 10;
  5186.     cutlim = NGX_MAX_INT_T_VALUE % 10;

  5188.     n = 0;

  5190.     for ( /* void */ ; p < last; p++) {
  5191.         if (*p == ',' || *p == ';' || *p == ' ') {
  5192.             break;
  5193.         }

  5195.         if (*p < '0' || *p > '9') {
  5196.             return NGX_ERROR;
  5197.         }

  5199.         if (n >= cutoff && (n > cutoff || *p - '0' > cutlim)) {
  5200.             n = NGX_MAX_INT_T_VALUE;
  5201.             break;
  5202.         }

  5204.         n = n * 10 + (*p - '0');
  5205.     }

  5207.     return n;
  5208. }

  5210. #endif


  5213. static ngx_int_t
  5214. ‌ngx_http_upstream_process_expires(ngx_http_request_t *r, ngx_table_elt_t *h,
  5215.     ngx_uint_t offset)
  5216. {
  5217.     ngx_http_upstream_t  *u;

  5219.     u = r->upstream;

  5221.     if (u->headers_in.expires) {
  5222.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5223.                       "upstream sent duplicate header line: \"%V: %V\", "
  5224.                       "previous value: \"%V: %V\", ignored",
  5225.                       &h->key, &h->value,
  5226.                       &u->headers_in.expires->key,
  5227.                       &u->headers_in.expires->value);
  5228.         h->hash = 0;
  5229.         return NGX_OK;
  5230.     }

  5232.     u->headers_in.expires = h;
  5233.     h->next = NULL;

  5235. #if (NGX_HTTP_CACHE)
  5236.     {
  5237.     time_t  expires;

  5239.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_EXPIRES) {
  5240.         return NGX_OK;
  5241.     }

  5243.     if (r->cache == NULL) {
  5244.         return NGX_OK;
  5245.     }

  5247.     if (r->cache->valid_sec != 0) {
  5248.         return NGX_OK;
  5249.     }

  5251.     expires = ngx_parse_http_time(h->value.data, h->value.len);

  5253.     if (expires == NGX_ERROR || expires < ngx_time()) {
  5254.         u->headers_in.expired = 1;
  5255.         return NGX_OK;
  5256.     }

  5258.     r->cache->valid_sec = expires;
  5259.     }
  5260. #endif

  5262.     return NGX_OK;
  5263. }


  5266. static ngx_int_t
  5267. ‌ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  5268.     ngx_table_elt_t *h, ngx_uint_t offset)
  5269. {
  5270.     ngx_http_upstream_t  *u;

  5272.     u = r->upstream;

  5274.     if (u->headers_in.x_accel_expires) {
  5275.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5276.                       "upstream sent duplicate header line: \"%V: %V\", "
  5277.                       "previous value: \"%V: %V\", ignored",
  5278.                       &h->key, &h->value,
  5279.                       &u->headers_in.x_accel_expires->key,
  5280.                       &u->headers_in.x_accel_expires->value);
  5281.         h->hash = 0;
  5282.         return NGX_OK;
  5283.     }

  5285.     u->headers_in.x_accel_expires = h;
  5286.     h->next = NULL;

  5288. #if (NGX_HTTP_CACHE)
  5289.     {
  5290.     u_char     *p;
  5291.     size_t      len;
  5292.     ngx_int_t   n;

  5294.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES) {
  5295.         return NGX_OK;
  5296.     }

  5298.     if (r->cache == NULL) {
  5299.         return NGX_OK;
  5300.     }

  5302.     len = h->value.len;
  5303.     p = h->value.data;

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

  5308.         switch (n) {
  5309.         case 0:
  5310.             u->cacheable = 0;
  5311.             /* fall through */

  5313.         case NGX_ERROR:
  5314.             return NGX_OK;

  5316.         default:
  5317.             r->cache->valid_sec = ngx_time() + n;
  5318.             u->headers_in.no_cache = 0;
  5319.             u->headers_in.expired = 0;
  5320.             return NGX_OK;
  5321.         }
  5322.     }

  5324.     p++;
  5325.     len--;

  5327.     n = ngx_atoi(p, len);

  5329.     if (n != NGX_ERROR) {
  5330.         r->cache->valid_sec = n;
  5331.         u->headers_in.no_cache = 0;
  5332.         u->headers_in.expired = 0;
  5333.     }
  5334.     }
  5335. #endif

  5337.     return NGX_OK;
  5338. }


  5341. static ngx_int_t
  5342. ‌ngx_http_upstream_process_limit_rate(ngx_http_request_t *r, ngx_table_elt_t *h,
  5343.     ngx_uint_t offset)
  5344. {
  5345.     ngx_int_t             n;
  5346.     ngx_http_upstream_t  *u;

  5348.     u = r->upstream;

  5350.     if (u->headers_in.x_accel_limit_rate) {
  5351.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5352.                       "upstream sent duplicate header line: \"%V: %V\", "
  5353.                       "previous value: \"%V: %V\", ignored",
  5354.                       &h->key, &h->value,
  5355.                       &u->headers_in.x_accel_limit_rate->key,
  5356.                       &u->headers_in.x_accel_limit_rate->value);
  5357.         h->hash = 0;
  5358.         return NGX_OK;
  5359.     }

  5361.     u->headers_in.x_accel_limit_rate = h;
  5362.     h->next = NULL;

  5364.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE) {
  5365.         return NGX_OK;
  5366.     }

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

  5370.     if (n != NGX_ERROR) {
  5371.         r->limit_rate = (size_t) n;
  5372.         r->limit_rate_set = 1;
  5373.     }

  5375.     return NGX_OK;
  5376. }


  5379. static ngx_int_t
  5380. ‌ngx_http_upstream_process_buffering(ngx_http_request_t *r, ngx_table_elt_t *h,
  5381.     ngx_uint_t offset)
  5382. {
  5383.     u_char                c0, c1, c2;
  5384.     ngx_http_upstream_t  *u;

  5386.     u = r->upstream;

  5388.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING) {
  5389.         return NGX_OK;
  5390.     }

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

  5394.         if (h->value.len == 2) {
  5395.             c0 = ngx_tolower(h->value.data[0]);
  5396.             c1 = ngx_tolower(h->value.data[1]);

  5398.             if (c0 == 'n' && c1 == 'o') {
  5399.                 u->buffering = 0;
  5400.             }

  5402.         } else if (h->value.len == 3) {
  5403.             c0 = ngx_tolower(h->value.data[0]);
  5404.             c1 = ngx_tolower(h->value.data[1]);
  5405.             c2 = ngx_tolower(h->value.data[2]);

  5407.             if (c0 == 'y' && c1 == 'e' && c2 == 's') {
  5408.                 u->buffering = 1;
  5409.             }
  5410.         }
  5411.     }

  5413.     return NGX_OK;
  5414. }


  5417. static ngx_int_t
  5418. ‌ngx_http_upstream_process_charset(ngx_http_request_t *r, ngx_table_elt_t *h,
  5419.     ngx_uint_t offset)
  5420. {
  5421.     ngx_http_upstream_t  *u;

  5423.     u = r->upstream;

  5425.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_CHARSET) {
  5426.         return NGX_OK;
  5427.     }

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

  5431.     return NGX_OK;
  5432. }


  5435. static ngx_int_t
  5436. ‌ngx_http_upstream_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  5437.     ngx_uint_t offset)
  5438. {
  5439.     ngx_table_elt_t      **ph;
  5440.     ngx_http_upstream_t   *u;

  5442.     u = r->upstream;
  5443.     ph = &u->headers_in.connection;

  5445.     while (*ph) { ph = &(*ph)->next; }

  5447.     *ph = h;
  5448.     h->next = NULL;

  5450.     if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
  5451.                          (u_char *) "close", 5 - 1)
  5452.         != NULL)
  5453.     {
  5454.         u->headers_in.connection_close = 1;
  5455.     }

  5457.     return NGX_OK;
  5458. }


  5461. static ngx_int_t
  5462. ‌ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  5463.     ngx_table_elt_t *h, ngx_uint_t offset)
  5464. {
  5465.     ngx_http_upstream_t  *u;

  5467.     u = r->upstream;

  5469.     if (u->headers_in.transfer_encoding) {
  5470.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5471.                       "upstream sent duplicate header line: \"%V: %V\", "
  5472.                       "previous value: \"%V: %V\"",
  5473.                       &h->key, &h->value,
  5474.                       &u->headers_in.transfer_encoding->key,
  5475.                       &u->headers_in.transfer_encoding->value);
  5476.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5477.     }

  5479.     if (u->headers_in.content_length) {
  5480.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5481.                       "upstream sent \"Content-Length\" and "
  5482.                       "\"Transfer-Encoding\" headers at the same time");
  5483.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5484.     }

  5486.     u->headers_in.transfer_encoding = h;
  5487.     h->next = NULL;

  5489.     if (h->value.len == 7
  5490.         && ngx_strncasecmp(h->value.data, (u_char *) "chunked", 7) == 0)
  5491.     {
  5492.         u->headers_in.chunked = 1;

  5494.     } else {
  5495.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5496.                       "upstream sent unknown \"Transfer-Encoding\": \"%V\"",
  5497.                       &h->value);
  5498.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5499.     }

  5501.     return NGX_OK;
  5502. }


  5505. static ngx_int_t
  5506. ‌ngx_http_upstream_process_vary(ngx_http_request_t *r,
  5507.     ngx_table_elt_t *h, ngx_uint_t offset)
  5508. {
  5509.     ngx_table_elt_t      **ph;
  5510.     ngx_http_upstream_t   *u;

  5512.     u = r->upstream;
  5513.     ph = &u->headers_in.vary;

  5515.     while (*ph) { ph = &(*ph)->next; }

  5517.     *ph = h;
  5518.     h->next = NULL;

  5520. #if (NGX_HTTP_CACHE)
  5521.     {
  5522.     u_char     *p;
  5523.     size_t      len;
  5524.     ngx_str_t   vary;

  5526.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_VARY) {
  5527.         return NGX_OK;
  5528.     }

  5530.     if (r->cache == NULL || !u->cacheable) {
  5531.         return NGX_OK;
  5532.     }

  5534.     if (h->value.len == 1 && h->value.data[0] == '*') {
  5535.         u->cacheable = 0;
  5536.         return NGX_OK;
  5537.     }

  5539.     if (u->headers_in.vary->next) {

  5541.         len = 0;

  5543.         for (h = u->headers_in.vary; h; h = h->next) {
  5544.             len += h->value.len + 2;
  5545.         }

  5547.         len -= 2;

  5549.         p = ngx_pnalloc(r->pool, len);
  5550.         if (p == NULL) {
  5551.             return NGX_ERROR;
  5552.         }

  5554.         vary.len = len;
  5555.         vary.data = p;

  5557.         for (h = u->headers_in.vary; h; h = h->next) {
  5558.             p = ngx_copy(p, h->value.data, h->value.len);

  5560.             if (h->next == NULL) {
  5561.                 break;
  5562.             }

  5564.             *p++ = ','; *p++ = ' ';
  5565.         }

  5567.     } else {
  5568.         vary = h->value;
  5569.     }

  5571.     if (vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  5572.         u->cacheable = 0;
  5573.     }

  5575.     r->cache->vary = vary;
  5576.     }
  5577. #endif

  5579.     return NGX_OK;
  5580. }


  5583. static ngx_int_t
  5584. ‌ngx_http_upstream_copy_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  5585.     ngx_uint_t offset)
  5586. {
  5587.     ngx_table_elt_t  *ho, **ph;

  5589.     ho = ngx_list_push(&r->headers_out.headers);
  5590.     if (ho == NULL) {
  5591.         return NGX_ERROR;
  5592.     }

  5594.     *ho = *h;

  5596.     if (offset) {
  5597.         ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);
  5598.         *ph = ho;
  5599.         ho->next = NULL;
  5600.     }

  5602.     return NGX_OK;
  5603. }


  5606. static ngx_int_t
  5607. ‌ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  5608.     ngx_table_elt_t *h, ngx_uint_t offset)
  5609. {
  5610.     ngx_table_elt_t  *ho, **ph;

  5612.     ho = ngx_list_push(&r->headers_out.headers);
  5613.     if (ho == NULL) {
  5614.         return NGX_ERROR;
  5615.     }

  5617.     *ho = *h;

  5619.     ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);

  5621.     while (*ph) { ph = &(*ph)->next; }

  5623.     *ph = ho;
  5624.     ho->next = NULL;

  5626.     return NGX_OK;
  5627. }


  5630. static ngx_int_t
  5631. ‌ngx_http_upstream_copy_content_type(ngx_http_request_t *r, ngx_table_elt_t *h,
  5632.     ngx_uint_t offset)
  5633. {
  5634.     u_char  *p, *last;

  5636.     r->headers_out.content_type_len = h->value.len;
  5637.     r->headers_out.content_type = h->value;
  5638.     r->headers_out.content_type_lowcase = NULL;

  5640.     for (p = h->value.data; *p; p++) {

  5642.         if (*p != ';') {
  5643.             continue;
  5644.         }

  5646.         last = p;

  5648.         while (*++p == ' ') { /* void */ }

  5650.         if (*p == '\0') {
  5651.             return NGX_OK;
  5652.         }

  5654.         if (ngx_strncasecmp(p, (u_char *) "charset=", 8) != 0) {
  5655.             continue;
  5656.         }

  5658.         p += 8;

  5660.         r->headers_out.content_type_len = last - h->value.data;

  5662.         if (*p == '"') {
  5663.             p++;
  5664.         }

  5666.         last = h->value.data + h->value.len;

  5668.         if (last > p && *(last - 1) == '"') {
  5669.             last--;
  5670.         }

  5672.         r->headers_out.charset.len = last - p;
  5673.         r->headers_out.charset.data = p;

  5675.         return NGX_OK;
  5676.     }

  5678.     return NGX_OK;
  5679. }


  5682. static ngx_int_t
  5683. ‌ngx_http_upstream_copy_last_modified(ngx_http_request_t *r, ngx_table_elt_t *h,
  5684.     ngx_uint_t offset)
  5685. {
  5686.     ngx_table_elt_t  *ho;

  5688.     ho = ngx_list_push(&r->headers_out.headers);
  5689.     if (ho == NULL) {
  5690.         return NGX_ERROR;
  5691.     }

  5693.     *ho = *h;
  5694.     ho->next = NULL;

  5696.     r->headers_out.last_modified = ho;
  5697.     r->headers_out.last_modified_time =
  5698.                                     r->upstream->headers_in.last_modified_time;

  5700.     return NGX_OK;
  5701. }


  5704. static ngx_int_t
  5705. ‌ngx_http_upstream_rewrite_location(ngx_http_request_t *r, ngx_table_elt_t *h,
  5706.     ngx_uint_t offset)
  5707. {
  5708.     ngx_int_t         rc;
  5709.     ngx_table_elt_t  *ho;

  5711.     ho = ngx_list_push(&r->headers_out.headers);
  5712.     if (ho == NULL) {
  5713.         return NGX_ERROR;
  5714.     }

  5716.     *ho = *h;
  5717.     ho->next = NULL;

  5719.     if (r->upstream->rewrite_redirect) {
  5720.         rc = r->upstream->rewrite_redirect(r, ho, 0);

  5722.         if (rc == NGX_DECLINED) {
  5723.             return NGX_OK;
  5724.         }

  5726.         if (rc == NGX_OK) {
  5727.             r->headers_out.location = ho;

  5729.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5730.                            "rewritten location: \"%V\"", &ho->value);
  5731.         }

  5733.         return rc;
  5734.     }

  5736.     if (ho->value.data[0] != '/') {
  5737.         r->headers_out.location = ho;
  5738.     }

  5740.     /*
  5741.      * we do not set r->headers_out.location here to avoid handling
  5742.      * relative redirects in ngx_http_header_filter()
  5743.      */

  5745.     return NGX_OK;
  5746. }


  5749. static ngx_int_t
  5750. ‌ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r, ngx_table_elt_t *h,
  5751.     ngx_uint_t offset)
  5752. {
  5753.     u_char           *p;
  5754.     ngx_int_t         rc;
  5755.     ngx_table_elt_t  *ho;

  5757.     ho = ngx_list_push(&r->headers_out.headers);
  5758.     if (ho == NULL) {
  5759.         return NGX_ERROR;
  5760.     }

  5762.     *ho = *h;
  5763.     ho->next = NULL;

  5765.     if (r->upstream->rewrite_redirect) {

  5767.         p = ngx_strcasestrn(ho->value.data, "url=", 4 - 1);

  5769.         if (p) {
  5770.             rc = r->upstream->rewrite_redirect(r, ho, p + 4 - ho->value.data);

  5772.         } else {
  5773.             return NGX_OK;
  5774.         }

  5776.         if (rc == NGX_DECLINED) {
  5777.             return NGX_OK;
  5778.         }

  5780.         if (rc == NGX_OK) {
  5781.             r->headers_out.refresh = ho;

  5783.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5784.                            "rewritten refresh: \"%V\"", &ho->value);
  5785.         }

  5787.         return rc;
  5788.     }

  5790.     r->headers_out.refresh = ho;

  5792.     return NGX_OK;
  5793. }


  5796. static ngx_int_t
  5797. ‌ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5798.     ngx_uint_t offset)
  5799. {
  5800.     ngx_int_t         rc;
  5801.     ngx_table_elt_t  *ho;

  5803.     ho = ngx_list_push(&r->headers_out.headers);
  5804.     if (ho == NULL) {
  5805.         return NGX_ERROR;
  5806.     }

  5808.     *ho = *h;
  5809.     ho->next = NULL;

  5811.     if (r->upstream->rewrite_cookie) {
  5812.         rc = r->upstream->rewrite_cookie(r, ho);

  5814.         if (rc == NGX_DECLINED) {
  5815.             return NGX_OK;
  5816.         }

  5818. #if (NGX_DEBUG)
  5819.         if (rc == NGX_OK) {
  5820.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5821.                            "rewritten cookie: \"%V\"", &ho->value);
  5822.         }
  5823. #endif

  5825.         return rc;
  5826.     }

  5828.     return NGX_OK;
  5829. }


  5832. static ngx_int_t
  5833. ‌ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  5834.     ngx_table_elt_t *h, ngx_uint_t offset)
  5835. {
  5836.     ngx_table_elt_t  *ho;

  5838.     if (r->upstream->conf->force_ranges) {
  5839.         return NGX_OK;
  5840.     }

  5842. #if (NGX_HTTP_CACHE)

  5844.     if (r->cached) {
  5845.         r->allow_ranges = 1;
  5846.         return NGX_OK;
  5847.     }

  5849.     if (r->upstream->cacheable) {
  5850.         r->allow_ranges = 1;
  5851.         r->single_range = 1;
  5852.         return NGX_OK;
  5853.     }

  5855. #endif

  5857.     ho = ngx_list_push(&r->headers_out.headers);
  5858.     if (ho == NULL) {
  5859.         return NGX_ERROR;
  5860.     }

  5862.     *ho = *h;
  5863.     ho->next = NULL;

  5865.     r->headers_out.accept_ranges = ho;

  5867.     return NGX_OK;
  5868. }


  5871. static ngx_int_t
  5872. ‌ngx_http_upstream_add_variables(ngx_conf_t *cf)
  5873. {
  5874.     ngx_http_variable_t  *var, *v;

  5876.     for (v = ngx_http_upstream_vars; v->name.len; v++) {
  5877.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  5878.         if (var == NULL) {
  5879.             return NGX_ERROR;
  5880.         }

  5882.         var->get_handler = v->get_handler;
  5883.         var->data = v->data;
  5884.     }

  5886.     return NGX_OK;
  5887. }


  5890. static ngx_int_t
  5891. ‌ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  5892.     ngx_http_variable_value_t *v, uintptr_t data)
  5893. {
  5894.     u_char                     *p;
  5895.     size_t                      len;
  5896.     ngx_uint_t                  i;
  5897.     ngx_http_upstream_state_t  *state;

  5899.     v->valid = 1;
  5900.     v->no_cacheable = 0;
  5901.     v->not_found = 0;

  5903.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5904.         v->not_found = 1;
  5905.         return NGX_OK;
  5906.     }

  5908.     len = 0;
  5909.     state = r->upstream_states->elts;

  5911.     for (i = 0; i < r->upstream_states->nelts; i++) {
  5912.         if (state[i].peer) {
  5913.             len += state[i].peer->len + 2;

  5915.         } else {
  5916.             len += 3;
  5917.         }
  5918.     }

  5920.     p = ngx_pnalloc(r->pool, len);
  5921.     if (p == NULL) {
  5922.         return NGX_ERROR;
  5923.     }

  5925.     v->data = p;

  5927.     i = 0;

  5929.     for ( ;; ) {
  5930.         if (state[i].peer) {
  5931.             p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
  5932.         }

  5934.         if (++i == r->upstream_states->nelts) {
  5935.             break;
  5936.         }

  5938.         if (state[i].peer) {
  5939.             *p++ = ',';
  5940.             *p++ = ' ';

  5942.         } else {
  5943.             *p++ = ' ';
  5944.             *p++ = ':';
  5945.             *p++ = ' ';

  5947.             if (++i == r->upstream_states->nelts) {
  5948.                 break;
  5949.             }

  5951.             continue;
  5952.         }
  5953.     }

  5955.     v->len = p - v->data;

  5957.     return NGX_OK;
  5958. }


  5961. static ngx_int_t
  5962. ‌ngx_http_upstream_status_variable(ngx_http_request_t *r,
  5963.     ngx_http_variable_value_t *v, uintptr_t data)
  5964. {
  5965.     u_char                     *p;
  5966.     size_t                      len;
  5967.     ngx_uint_t                  i;
  5968.     ngx_http_upstream_state_t  *state;

  5970.     v->valid = 1;
  5971.     v->no_cacheable = 0;
  5972.     v->not_found = 0;

  5974.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5975.         v->not_found = 1;
  5976.         return NGX_OK;
  5977.     }

  5979.     len = r->upstream_states->nelts * (3 + 2);

  5981.     p = ngx_pnalloc(r->pool, len);
  5982.     if (p == NULL) {
  5983.         return NGX_ERROR;
  5984.     }

  5986.     v->data = p;

  5988.     i = 0;
  5989.     state = r->upstream_states->elts;

  5991.     for ( ;; ) {
  5992.         if (state[i].status) {
  5993.             p = ngx_sprintf(p, "%ui", state[i].status);

  5995.         } else {
  5996.             *p++ = '-';
  5997.         }

  5999.         if (++i == r->upstream_states->nelts) {
  6000.             break;
  6001.         }

  6003.         if (state[i].peer) {
  6004.             *p++ = ',';
  6005.             *p++ = ' ';

  6007.         } else {
  6008.             *p++ = ' ';
  6009.             *p++ = ':';
  6010.             *p++ = ' ';

  6012.             if (++i == r->upstream_states->nelts) {
  6013.                 break;
  6014.             }

  6016.             continue;
  6017.         }
  6018.     }

  6020.     v->len = p - v->data;

  6022.     return NGX_OK;
  6023. }


  6026. static ngx_int_t
  6027. ‌ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  6028.     ngx_http_variable_value_t *v, uintptr_t data)
  6029. {
  6030.     u_char                     *p;
  6031.     size_t                      len;
  6032.     ngx_uint_t                  i;
  6033.     ngx_msec_int_t              ms;
  6034.     ngx_http_upstream_state_t  *state;

  6036.     v->valid = 1;
  6037.     v->no_cacheable = 0;
  6038.     v->not_found = 0;

  6040.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6041.         v->not_found = 1;
  6042.         return NGX_OK;
  6043.     }

  6045.     len = r->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);

  6047.     p = ngx_pnalloc(r->pool, len);
  6048.     if (p == NULL) {
  6049.         return NGX_ERROR;
  6050.     }

  6052.     v->data = p;

  6054.     i = 0;
  6055.     state = r->upstream_states->elts;

  6057.     for ( ;; ) {

  6059.         if (data == 1) {
  6060.             ms = state[i].header_time;

  6062.         } else if (data == 2) {
  6063.             ms = state[i].connect_time;

  6065.         } else {
  6066.             ms = state[i].response_time;
  6067.         }

  6069.         if (ms != -1) {
  6070.             ms = ngx_max(ms, 0);
  6071.             p = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000);

  6073.         } else {
  6074.             *p++ = '-';
  6075.         }

  6077.         if (++i == r->upstream_states->nelts) {
  6078.             break;
  6079.         }

  6081.         if (state[i].peer) {
  6082.             *p++ = ',';
  6083.             *p++ = ' ';

  6085.         } else {
  6086.             *p++ = ' ';
  6087.             *p++ = ':';
  6088.             *p++ = ' ';

  6090.             if (++i == r->upstream_states->nelts) {
  6091.                 break;
  6092.             }

  6094.             continue;
  6095.         }
  6096.     }

  6098.     v->len = p - v->data;

  6100.     return NGX_OK;
  6101. }


  6104. static ngx_int_t
  6105. ‌ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
  6106.     ngx_http_variable_value_t *v, uintptr_t data)
  6107. {
  6108.     u_char                     *p;
  6109.     size_t                      len;
  6110.     ngx_uint_t                  i;
  6111.     ngx_http_upstream_state_t  *state;

  6113.     v->valid = 1;
  6114.     v->no_cacheable = 0;
  6115.     v->not_found = 0;

  6117.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6118.         v->not_found = 1;
  6119.         return NGX_OK;
  6120.     }

  6122.     len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);

  6124.     p = ngx_pnalloc(r->pool, len);
  6125.     if (p == NULL) {
  6126.         return NGX_ERROR;
  6127.     }

  6129.     v->data = p;

  6131.     i = 0;
  6132.     state = r->upstream_states->elts;

  6134.     for ( ;; ) {

  6136.         if (data == 1) {
  6137.             p = ngx_sprintf(p, "%O", state[i].bytes_received);

  6139.         } else if (data == 2) {
  6140.             p = ngx_sprintf(p, "%O", state[i].bytes_sent);

  6142.         } else {
  6143.             p = ngx_sprintf(p, "%O", state[i].response_length);
  6144.         }

  6146.         if (++i == r->upstream_states->nelts) {
  6147.             break;
  6148.         }

  6150.         if (state[i].peer) {
  6151.             *p++ = ',';
  6152.             *p++ = ' ';

  6154.         } else {
  6155.             *p++ = ' ';
  6156.             *p++ = ':';
  6157.             *p++ = ' ';

  6159.             if (++i == r->upstream_states->nelts) {
  6160.                 break;
  6161.             }

  6163.             continue;
  6164.         }
  6165.     }

  6167.     v->len = p - v->data;

  6169.     return NGX_OK;
  6170. }


  6173. static ngx_int_t
  6174. ‌ngx_http_upstream_header_variable(ngx_http_request_t *r,
  6175.     ngx_http_variable_value_t *v, uintptr_t data)
  6176. {
  6177.     if (r->upstream == NULL) {
  6178.         v->not_found = 1;
  6179.         return NGX_OK;
  6180.     }

  6182.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  6183.                                          &r->upstream->headers_in.headers.part,
  6184.                                          sizeof("upstream_http_") - 1);
  6185. }


  6188. static ngx_int_t
  6189. ‌ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  6190.     ngx_http_variable_value_t *v, uintptr_t data)
  6191. {
  6192.     if (r->upstream == NULL) {
  6193.         v->not_found = 1;
  6194.         return NGX_OK;
  6195.     }

  6197.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  6198.                                         &r->upstream->headers_in.trailers.part,
  6199.                                         sizeof("upstream_trailer_") - 1);
  6200. }


  6203. static ngx_int_t
  6204. ‌ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  6205.     ngx_http_variable_value_t *v, uintptr_t data)
  6206. {
  6207.     ngx_str_t  *name = (ngx_str_t *) data;

  6209.     ngx_str_t   cookie, s;

  6211.     if (r->upstream == NULL) {
  6212.         v->not_found = 1;
  6213.         return NGX_OK;
  6214.     }

  6216.     s.len = name->len - (sizeof("upstream_cookie_") - 1);
  6217.     s.data = name->data + sizeof("upstream_cookie_") - 1;

  6219.     if (ngx_http_parse_set_cookie_lines(r, r->upstream->headers_in.set_cookie,
  6220.                                         &s, &cookie)
  6221.         == NULL)
  6222.     {
  6223.         v->not_found = 1;
  6224.         return NGX_OK;
  6225.     }

  6227.     v->len = cookie.len;
  6228.     v->valid = 1;
  6229.     v->no_cacheable = 0;
  6230.     v->not_found = 0;
  6231.     v->data = cookie.data;

  6233.     return NGX_OK;
  6234. }


  6237. #if (NGX_HTTP_CACHE)

  6239. static ngx_int_t
  6240. ‌ngx_http_upstream_cache_status(ngx_http_request_t *r,
  6241.     ngx_http_variable_value_t *v, uintptr_t data)
  6242. {
  6243.     ngx_uint_t  n;

  6245.     if (r->upstream == NULL || r->upstream->cache_status == 0) {
  6246.         v->not_found = 1;
  6247.         return NGX_OK;
  6248.     }

  6250.     n = r->upstream->cache_status - 1;

  6252.     v->valid = 1;
  6253.     v->no_cacheable = 0;
  6254.     v->not_found = 0;
  6255.     v->len = ngx_http_cache_status[n].len;
  6256.     v->data = ngx_http_cache_status[n].data;

  6258.     return NGX_OK;
  6259. }


  6262. static ngx_int_t
  6263. ‌ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  6264.     ngx_http_variable_value_t *v, uintptr_t data)
  6265. {
  6266.     u_char  *p;

  6268.     if (r->upstream == NULL
  6269.         || !r->upstream->conf->cache_revalidate
  6270.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6271.         || r->cache->last_modified == -1)
  6272.     {
  6273.         v->not_found = 1;
  6274.         return NGX_OK;
  6275.     }

  6277.     p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  6278.     if (p == NULL) {
  6279.         return NGX_ERROR;
  6280.     }

  6282.     v->len = ngx_http_time(p, r->cache->last_modified) - p;
  6283.     v->valid = 1;
  6284.     v->no_cacheable = 0;
  6285.     v->not_found = 0;
  6286.     v->data = p;

  6288.     return NGX_OK;
  6289. }


  6292. static ngx_int_t
  6293. ‌ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  6294.     ngx_http_variable_value_t *v, uintptr_t data)
  6295. {
  6296.     if (r->upstream == NULL
  6297.         || !r->upstream->conf->cache_revalidate
  6298.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6299.         || r->cache->etag.len == 0)
  6300.     {
  6301.         v->not_found = 1;
  6302.         return NGX_OK;
  6303.     }

  6305.     v->valid = 1;
  6306.     v->no_cacheable = 0;
  6307.     v->not_found = 0;
  6308.     v->len = r->cache->etag.len;
  6309.     v->data = r->cache->etag.data;

  6311.     return NGX_OK;
  6312. }

  6314. #endif


  6317. static char *
  6318. ‌ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  6319. {
  6320.     char                          *rv;
  6321.     void                          *mconf;
  6322.     ngx_str_t                     *value;
  6323.     ngx_url_t                      u;
  6324.     ngx_uint_t                     m;
  6325.     ngx_conf_t                     pcf;
  6326.     ngx_http_module_t             *module;
  6327.     ngx_http_conf_ctx_t           *ctx, *http_ctx;
  6328.     ngx_http_upstream_srv_conf_t  *uscf;

  6330.     ngx_memzero(&u, sizeof(ngx_url_t));

  6332.     value = cf->args->elts;
  6333.     u.host = value[1];
  6334.     u.no_resolve = 1;
  6335.     u.no_port = 1;

  6337.     uscf = ngx_http_upstream_add(cf, &u, NGX_HTTP_UPSTREAM_CREATE
  6338.                                          |NGX_HTTP_UPSTREAM_MODIFY
  6339.                                          |NGX_HTTP_UPSTREAM_WEIGHT
  6340.                                          |NGX_HTTP_UPSTREAM_MAX_CONNS
  6341.                                          |NGX_HTTP_UPSTREAM_MAX_FAILS
  6342.                                          |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  6343.                                          |NGX_HTTP_UPSTREAM_DOWN
  6344.                                          |NGX_HTTP_UPSTREAM_BACKUP);
  6345.     if (uscf == NULL) {
  6346.         return NGX_CONF_ERROR;
  6347.     }


  6350.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  6351.     if (ctx == NULL) {
  6352.         return NGX_CONF_ERROR;
  6353.     }

  6355.     http_ctx = cf->ctx;
  6356.     ctx->main_conf = http_ctx->main_conf;

  6358.     /* the upstream{}'s srv_conf */

  6360.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6361.     if (ctx->srv_conf == NULL) {
  6362.         return NGX_CONF_ERROR;
  6363.     }

  6365.     ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;

  6367.     uscf->srv_conf = ctx->srv_conf;


  6370.     /* the upstream{}'s loc_conf */

  6372.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6373.     if (ctx->loc_conf == NULL) {
  6374.         return NGX_CONF_ERROR;
  6375.     }

  6377.     for (m = 0; cf->cycle->modules[m]; m++) {
  6378.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  6379.             continue;
  6380.         }

  6382.         module = cf->cycle->modules[m]->ctx;

  6384.         if (module->create_srv_conf) {
  6385.             mconf = module->create_srv_conf(cf);
  6386.             if (mconf == NULL) {
  6387.                 return NGX_CONF_ERROR;
  6388.             }

  6390.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6391.         }

  6393.         if (module->create_loc_conf) {
  6394.             mconf = module->create_loc_conf(cf);
  6395.             if (mconf == NULL) {
  6396.                 return NGX_CONF_ERROR;
  6397.             }

  6399.             ctx->loc_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6400.         }
  6401.     }

  6403.     uscf->servers = ngx_array_create(cf->pool, 4,
  6404.                                      sizeof(ngx_http_upstream_server_t));
  6405.     if (uscf->servers == NULL) {
  6406.         return NGX_CONF_ERROR;
  6407.     }


  6410.     /* parse inside upstream{} */

  6412.     pcf = *cf;
  6413.     cf->ctx = ctx;
  6414.     cf->cmd_type = NGX_HTTP_UPS_CONF;

  6416.     rv = ngx_conf_parse(cf, NULL);

  6418.     *cf = pcf;

  6420.     if (rv != NGX_CONF_OK) {
  6421.         return rv;
  6422.     }

  6424.     if (uscf->servers->nelts == 0) {
  6425.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6426.                            "no servers are inside upstream");
  6427.         return NGX_CONF_ERROR;
  6428.     }

  6430.     return rv;
  6431. }


  6434. static char *
  6435. ‌ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6436. {
  6437.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6439.     time_t                       fail_timeout;
  6440.     ngx_str_t                   *value, s;
  6441.     ngx_url_t                    u;
  6442.     ngx_int_t                    weight, max_conns, max_fails;
  6443.     ngx_uint_t                   i;
  6444. #if (NGX_HTTP_UPSTREAM_ZONE)
  6445.     ngx_uint_t                   resolve;
  6446. #endif
  6447.     ngx_http_upstream_server_t  *us;

  6449.     us = ngx_array_push(uscf->servers);
  6450.     if (us == NULL) {
  6451.         return NGX_CONF_ERROR;
  6452.     }

  6454.     ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6456.     value = cf->args->elts;

  6458.     weight = 1;
  6459.     max_conns = 0;
  6460.     max_fails = 1;
  6461.     fail_timeout = 10;
  6462. #if (NGX_HTTP_UPSTREAM_ZONE)
  6463.     resolve = 0;
  6464. #endif

  6466.     for (i = 2; i < cf->args->nelts; i++) {

  6468.         if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {

  6470.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_WEIGHT)) {
  6471.                 goto not_supported;
  6472.             }

  6474.             weight = ngx_atoi(&value[i].data[7], value[i].len - 7);

  6476.             if (weight == NGX_ERROR || weight == 0) {
  6477.                 goto invalid;
  6478.             }

  6480.             continue;
  6481.         }

  6483.         if (ngx_strncmp(value[i].data, "max_conns=", 10) == 0) {

  6485.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_CONNS)) {
  6486.                 goto not_supported;
  6487.             }

  6489.             max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6491.             if (max_conns == NGX_ERROR) {
  6492.                 goto invalid;
  6493.             }

  6495.             continue;
  6496.         }

  6498.         if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {

  6500.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_FAILS)) {
  6501.                 goto not_supported;
  6502.             }

  6504.             max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6506.             if (max_fails == NGX_ERROR) {
  6507.                 goto invalid;
  6508.             }

  6510.             continue;
  6511.         }

  6513.         if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {

  6515.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_FAIL_TIMEOUT)) {
  6516.                 goto not_supported;
  6517.             }

  6519.             s.len = value[i].len - 13;
  6520.             s.data = &value[i].data[13];

  6522.             fail_timeout = ngx_parse_time(&s, 1);

  6524.             if (fail_timeout == (time_t) NGX_ERROR) {
  6525.                 goto invalid;
  6526.             }

  6528.             continue;
  6529.         }

  6531.         if (ngx_strcmp(value[i].data, "backup") == 0) {

  6533.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  6534.                 goto not_supported;
  6535.             }

  6537.             us->backup = 1;

  6539.             continue;
  6540.         }

  6542.         if (ngx_strcmp(value[i].data, "down") == 0) {

  6544.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6545.                 goto not_supported;
  6546.             }

  6548.             us->down = NGX_HTTP_UPSTREAM_FAILED;

  6550.             continue;
  6551.         }

  6553. #if (NGX_HTTP_UPSTREAM_STICKY)
  6554.         if (ngx_strcmp(value[i].data, "drain") == 0) {

  6556.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6557.                 goto not_supported;
  6558.             }

  6560.             us->down = NGX_HTTP_UPSTREAM_DRAINING;

  6562.             continue;
  6563.         }
  6564. #endif

  6566. #if (NGX_HTTP_UPSTREAM_SID)
  6567.         if (ngx_strncmp(value[i].data, "route=", 6) == 0) {

  6569.             us->sid.data = &value[i].data[6];
  6570.             us->sid.len = value[i].len - 6;

  6572.             if (us->sid.len == 0) {
  6573.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "route is empty");
  6574.                 return NGX_CONF_ERROR;
  6575.             }

  6577.             if (us->sid.len > NGX_HTTP_UPSTREAM_SID_LEN) {
  6578.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6579.                                    "route is longer than %d",
  6580.                                    NGX_HTTP_UPSTREAM_SID_LEN);
  6581.                 return NGX_CONF_ERROR;
  6582.             }

  6584.             continue;
  6585.         }
  6586. #endif

  6588. #if (NGX_HTTP_UPSTREAM_ZONE)
  6589.         if (ngx_strcmp(value[i].data, "resolve") == 0) {
  6590.             resolve = 1;
  6591.             continue;
  6592.         }

  6594.         if (ngx_strncmp(value[i].data, "service=", 8) == 0) {

  6596.             us->service.len = value[i].len - 8;
  6597.             us->service.data = &value[i].data[8];

  6599.             if (us->service.len == 0) {
  6600.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "service is empty");
  6601.                 return NGX_CONF_ERROR;
  6602.             }

  6604.             continue;
  6605.         }
  6606. #endif

  6608.         goto invalid;
  6609.     }

  6611.     ngx_memzero(&u, sizeof(ngx_url_t));

  6613.     u.url = value[1];
  6614.     u.default_port = 80;

  6616. #if (NGX_HTTP_UPSTREAM_ZONE)
  6617.     if (resolve) {
  6618.         /* resolve at run time */
  6619.         u.no_resolve = 1;
  6620.     }

  6622.     if (us->service.len && !resolve) {
  6623.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6624.                            "service upstream \"%V\" requires "
  6625.                            "\"resolve\" parameter",
  6626.                            &u.url);
  6627.         return NGX_CONF_ERROR;
  6628.     }

  6630. #endif

  6632.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  6633.         if (u.err) {
  6634.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6635.                                "%s in upstream \"%V\"", u.err, &u.url);
  6636.         }

  6638.         return NGX_CONF_ERROR;
  6639.     }

  6641.     us->name = u.url;

  6643. #if (NGX_HTTP_UPSTREAM_ZONE)

  6645.     if (us->service.len && !u.no_port) {
  6646.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6647.                            "service upstream \"%V\" may not have port",
  6648.                            &us->name);

  6650.         return NGX_CONF_ERROR;
  6651.     }

  6653.     if (us->service.len && u.naddrs) {
  6654.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6655.                            "service upstream \"%V\" requires domain name",
  6656.                            &us->name);

  6658.         return NGX_CONF_ERROR;
  6659.     }

  6661.     if (resolve && u.naddrs == 0) {
  6662.         ngx_addr_t  *addr;

  6664.         /* save port */

  6666.         addr = ngx_pcalloc(cf->pool, sizeof(ngx_addr_t));
  6667.         if (addr == NULL) {
  6668.             return NGX_CONF_ERROR;
  6669.         }

  6671.         addr->sockaddr = ngx_palloc(cf->pool, u.socklen);
  6672.         if (addr->sockaddr == NULL) {
  6673.             return NGX_CONF_ERROR;
  6674.         }

  6676.         ngx_memcpy(addr->sockaddr, &u.sockaddr, u.socklen);

  6678.         addr->socklen = u.socklen;

  6680.         us->addrs = addr;
  6681.         us->naddrs = 1;

  6683.         us->host = u.host;

  6685.     } else {
  6686.         us->addrs = u.addrs;
  6687.         us->naddrs = u.naddrs;
  6688.     }

  6690. #else

  6692.     us->addrs = u.addrs;
  6693.     us->naddrs = u.naddrs;

  6695. #endif

  6697.     us->weight = weight;
  6698.     us->max_conns = max_conns;
  6699.     us->max_fails = max_fails;
  6700.     us->fail_timeout = fail_timeout;

  6702.     return NGX_CONF_OK;

  6704. invalid:

  6706.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6707.                        "invalid parameter \"%V\"", &value[i]);

  6709.     return NGX_CONF_ERROR;

  6711. not_supported:

  6713.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6714.                        "balancing method does not support parameter \"%V\"",
  6715.                        &value[i]);

  6717.     return NGX_CONF_ERROR;
  6718. }


  6721. #if (NGX_HTTP_UPSTREAM_ZONE)

  6723. static char *
  6724. ‌ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6725. {
  6726.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6728.     ngx_str_t  *value;

  6730.     if (uscf->resolver) {
  6731.         return "is duplicate";
  6732.     }

  6734.     value = cf->args->elts;

  6736.     uscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  6737.     if (uscf->resolver == NULL) {
  6738.         return NGX_CONF_ERROR;
  6739.     }

  6741.     return NGX_CONF_OK;
  6742. }

  6744. #endif


  6747. ngx_http_upstream_srv_conf_t *
  6748. ‌ngx_http_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
  6749. {
  6750.     ngx_uint_t                      i;
  6751.     ngx_http_upstream_server_t     *us;
  6752.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  6753.     ngx_http_upstream_main_conf_t  *umcf;

  6755.     if (!(flags & NGX_HTTP_UPSTREAM_CREATE)) {

  6757.         if (ngx_parse_url(cf->pool, u) != NGX_OK) {
  6758.             if (u->err) {
  6759.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6760.                                    "%s in upstream \"%V\"", u->err, &u->url);
  6761.             }

  6763.             return NULL;
  6764.         }
  6765.     }

  6767.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

  6769.     uscfp = umcf->upstreams.elts;

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

  6773.         if (uscfp[i]->host.len != u->host.len
  6774.             || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
  6775.                != 0)
  6776.         {
  6777.             continue;
  6778.         }

  6780.         if ((flags & NGX_HTTP_UPSTREAM_CREATE)
  6781.              && (uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE))
  6782.         {
  6783.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6784.                                "duplicate upstream \"%V\"", &u->host);
  6785.             return NULL;
  6786.         }

  6788.         if ((uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE) && !u->no_port) {
  6789.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6790.                                "upstream \"%V\" may not have port %d",
  6791.                                &u->host, u->port);
  6792.             return NULL;
  6793.         }

  6795.         if ((flags & NGX_HTTP_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
  6796.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  6797.                           "upstream \"%V\" may not have port %d in %s:%ui",
  6798.                           &u->host, uscfp[i]->port,
  6799.                           uscfp[i]->file_name, uscfp[i]->line);
  6800.             return NULL;
  6801.         }

  6803.         if (uscfp[i]->port && u->port
  6804.             && uscfp[i]->port != u->port)
  6805.         {
  6806.             continue;
  6807.         }

  6809.         if (flags & NGX_HTTP_UPSTREAM_CREATE) {
  6810.             uscfp[i]->flags = flags;
  6811.             uscfp[i]->port = 0;
  6812.         }

  6814.         return uscfp[i];
  6815.     }

  6817.     uscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
  6818.     if (uscf == NULL) {
  6819.         return NULL;
  6820.     }

  6822.     uscf->flags = flags;
  6823.     uscf->host = u->host;
  6824.     uscf->file_name = cf->conf_file->file.name.data;
  6825.     uscf->line = cf->conf_file->line;
  6826.     uscf->port = u->port;
  6827.     uscf->no_port = u->no_port;
  6828. #if (NGX_HTTP_UPSTREAM_ZONE)
  6829.     uscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  6830. #endif

  6832.     if (u->naddrs == 1 && (u->port || u->family == AF_UNIX)) {
  6833.         uscf->servers = ngx_array_create(cf->pool, 1,
  6834.                                          sizeof(ngx_http_upstream_server_t));
  6835.         if (uscf->servers == NULL) {
  6836.             return NULL;
  6837.         }

  6839.         us = ngx_array_push(uscf->servers);
  6840.         if (us == NULL) {
  6841.             return NULL;
  6842.         }

  6844.         ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6846.         us->addrs = u->addrs;
  6847.         us->naddrs = 1;
  6848.     }

  6850.     uscfp = ngx_array_push(&umcf->upstreams);
  6851.     if (uscfp == NULL) {
  6852.         return NULL;
  6853.     }

  6855.     *uscfp = uscf;

  6857.     return uscf;
  6858. }


  6861. char *
  6862. ‌ngx_http_upstream_bind_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  6863.     void *conf)
  6864. {
  6865.     char  *p = conf;

  6867.     ngx_int_t                           rc;
  6868.     ngx_str_t                          *value;
  6869.     ngx_http_complex_value_t            cv;
  6870.     ngx_http_upstream_local_t         **plocal, *local;
  6871.     ngx_http_compile_complex_value_t    ccv;

  6873.     plocal = (ngx_http_upstream_local_t **) (p + cmd->offset);

  6875.     if (*plocal != NGX_CONF_UNSET_PTR) {
  6876.         return "is duplicate";
  6877.     }

  6879.     value = cf->args->elts;

  6881.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  6882.         *plocal = NULL;
  6883.         return NGX_CONF_OK;
  6884.     }

  6886.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  6888.     ccv.cf = cf;
  6889.     ccv.value = &value[1];
  6890.     ccv.complex_value = &cv;

  6892.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  6893.         return NGX_CONF_ERROR;
  6894.     }

  6896.     local = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_local_t));
  6897.     if (local == NULL) {
  6898.         return NGX_CONF_ERROR;
  6899.     }

  6901.     *plocal = local;

  6903.     if (cv.lengths) {
  6904.         local->value = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  6905.         if (local->value == NULL) {
  6906.             return NGX_CONF_ERROR;
  6907.         }

  6909.         *local->value = cv;

  6911.     } else {
  6912.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  6913.         if (local->addr == NULL) {
  6914.             return NGX_CONF_ERROR;
  6915.         }

  6917.         rc = ngx_parse_addr_port(cf->pool, local->addr, value[1].data,
  6918.                                  value[1].len);

  6920.         switch (rc) {
  6921.         case NGX_OK:
  6922.             local->addr->name = value[1];
  6923.             break;

  6925.         case NGX_DECLINED:
  6926.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6927.                                "invalid address \"%V\"", &value[1]);
  6928.             /* fall through */

  6930.         default:
  6931.             return NGX_CONF_ERROR;
  6932.         }
  6933.     }

  6935.     if (cf->args->nelts > 2) {
  6936.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  6937. #if (NGX_HAVE_TRANSPARENT_PROXY)
  6938.             ngx_core_conf_t  *ccf;

  6940.             ccf = (ngx_core_conf_t *) ngx_get_conf(cf->cycle->conf_ctx,
  6941.                                                    ngx_core_module);

  6943.             ccf->transparent = 1;
  6944.             local->transparent = 1;
  6945. #else
  6946.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6947.                                "transparent proxying is not supported "
  6948.                                "on this platform, ignored");
  6949. #endif
  6950.         } else {
  6951.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6952.                                "invalid parameter \"%V\"", &value[2]);
  6953.             return NGX_CONF_ERROR;
  6954.         }
  6955.     }

  6957.     return NGX_CONF_OK;
  6958. }


  6961. static ngx_int_t
  6962. ‌ngx_http_upstream_set_local(ngx_http_request_t *r, ngx_http_upstream_t *u,
  6963.     ngx_http_upstream_local_t *local)
  6964. {
  6965.     ngx_int_t    rc;
  6966.     ngx_str_t    val;
  6967.     ngx_addr_t  *addr;

  6969.     if (local == NULL) {
  6970.         u->peer.local = NULL;
  6971.         return NGX_OK;
  6972.     }

  6974. #if (NGX_HAVE_TRANSPARENT_PROXY)
  6975.     u->peer.transparent = local->transparent;
  6976. #endif

  6978.     if (local->value == NULL) {
  6979.         u->peer.local = local->addr;
  6980.         return NGX_OK;
  6981.     }

  6983.     if (ngx_http_complex_value(r, local->value, &val) != NGX_OK) {
  6984.         return NGX_ERROR;
  6985.     }

  6987.     if (val.len == 0) {
  6988.         u->peer.local = NULL;
  6989.         return NGX_OK;
  6990.     }

  6992.     addr = ngx_palloc(r->pool, sizeof(ngx_addr_t));
  6993.     if (addr == NULL) {
  6994.         return NGX_ERROR;
  6995.     }

  6997.     rc = ngx_parse_addr_port(r->pool, addr, val.data, val.len);
  6998.     if (rc == NGX_ERROR) {
  6999.         return NGX_ERROR;
  7000.     }

  7002.     if (rc != NGX_OK) {
  7003.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  7004.                       "invalid local address \"%V\"", &val);
  7005.         u->peer.local = NULL;
  7006.         return NGX_OK;
  7007.     }

  7009.     addr->name = val;
  7010.     u->peer.local = addr;

  7012.     return NGX_OK;
  7013. }


  7016. char *
  7017. ‌ngx_http_upstream_param_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  7018.     void *conf)
  7019. {
  7020.     char  *p = conf;

  7022.     ngx_str_t                   *value;
  7023.     ngx_array_t                **a;
  7024.     ngx_http_upstream_param_t   *param;

  7026.     a = (ngx_array_t **) (p + cmd->offset);

  7028.     if (*a == NULL) {
  7029.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_param_t));
  7030.         if (*a == NULL) {
  7031.             return NGX_CONF_ERROR;
  7032.         }
  7033.     }

  7035.     param = ngx_array_push(*a);
  7036.     if (param == NULL) {
  7037.         return NGX_CONF_ERROR;
  7038.     }

  7040.     value = cf->args->elts;

  7042.     param->key = value[1];
  7043.     param->value = value[2];
  7044.     param->skip_empty = 0;

  7046.     if (cf->args->nelts == 4) {
  7047.         if (ngx_strcmp(value[3].data, "if_not_empty") != 0) {
  7048.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  7049.                                "invalid parameter \"%V\"", &value[3]);
  7050.             return NGX_CONF_ERROR;
  7051.         }

  7053.         param->skip_empty = 1;
  7054.     }

  7056.     return NGX_CONF_OK;
  7057. }


  7060. ngx_int_t
  7061. ‌ngx_http_upstream_hide_headers_hash(ngx_conf_t *cf,
  7062.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev,
  7063.     ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
  7064. {
  7065.     ngx_str_t       *h;
  7066.     ngx_uint_t       i, j;
  7067.     ngx_array_t      hide_headers;
  7068.     ngx_hash_key_t  *hk;

  7070.     if (conf->hide_headers == NGX_CONF_UNSET_PTR
  7071.         && conf->pass_headers == NGX_CONF_UNSET_PTR)
  7072.     {
  7073.         conf->hide_headers = prev->hide_headers;
  7074.         conf->pass_headers = prev->pass_headers;

  7076.         conf->hide_headers_hash = prev->hide_headers_hash;

  7078.         if (conf->hide_headers_hash.buckets) {
  7079.             return NGX_OK;
  7080.         }

  7082.     } else {
  7083.         if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
  7084.             conf->hide_headers = prev->hide_headers;
  7085.         }

  7087.         if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
  7088.             conf->pass_headers = prev->pass_headers;
  7089.         }
  7090.     }

  7092.     if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  7093.         != NGX_OK)
  7094.     {
  7095.         return NGX_ERROR;
  7096.     }

  7098.     for (h = default_hide_headers; h->len; h++) {
  7099.         hk = ngx_array_push(&hide_headers);
  7100.         if (hk == NULL) {
  7101.             return NGX_ERROR;
  7102.         }

  7104.         hk->key = *h;
  7105.         hk->key_hash = ngx_hash_key_lc(h->data, h->len);
  7106.         hk->value = (void *) 1;
  7107.     }

  7109.     if (conf->hide_headers != NGX_CONF_UNSET_PTR) {

  7111.         h = conf->hide_headers->elts;

  7113.         for (i = 0; i < conf->hide_headers->nelts; i++) {

  7115.             hk = hide_headers.elts;

  7117.             for (j = 0; j < hide_headers.nelts; j++) {
  7118.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  7119.                     goto exist;
  7120.                 }
  7121.             }

  7123.             hk = ngx_array_push(&hide_headers);
  7124.             if (hk == NULL) {
  7125.                 return NGX_ERROR;
  7126.             }

  7128.             hk->key = h[i];
  7129.             hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
  7130.             hk->value = (void *) 1;

  7132.         exist:

  7134.             continue;
  7135.         }
  7136.     }

  7138.     if (conf->pass_headers != NGX_CONF_UNSET_PTR) {

  7140.         h = conf->pass_headers->elts;
  7141.         hk = hide_headers.elts;

  7143.         for (i = 0; i < conf->pass_headers->nelts; i++) {
  7144.             for (j = 0; j < hide_headers.nelts; j++) {

  7146.                 if (hk[j].key.data == NULL) {
  7147.                     continue;
  7148.                 }

  7150.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  7151.                     hk[j].key.data = NULL;
  7152.                     break;
  7153.                 }
  7154.             }
  7155.         }
  7156.     }

  7158.     hash->hash = &conf->hide_headers_hash;
  7159.     hash->key = ngx_hash_key_lc;
  7160.     hash->pool = cf->pool;
  7161.     hash->temp_pool = NULL;

  7163.     if (ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts) != NGX_OK) {
  7164.         return NGX_ERROR;
  7165.     }

  7167.     /*
  7168.      * special handling to preserve conf->hide_headers_hash
  7169.      * in the "http" section to inherit it to all servers
  7170.      */

  7172.     if (prev->hide_headers_hash.buckets == NULL
  7173.         && conf->hide_headers == prev->hide_headers
  7174.         && conf->pass_headers == prev->pass_headers)
  7175.     {
  7176.         prev->hide_headers_hash = conf->hide_headers_hash;
  7177.     }

  7179.     return NGX_OK;
  7180. }


  7183. #if (NGX_HTTP_SSL)

  7185. ngx_int_t
  7186. ‌ngx_http_upstream_merge_ssl_passwords(ngx_conf_t *cf,
  7187.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev)
  7188. {
  7189.     ngx_uint_t  preserve;

  7191.     ngx_conf_merge_ptr_value(conf->ssl_passwords, prev->ssl_passwords, NULL);

  7193.     if (conf->ssl_certificate == NULL
  7194.         || conf->ssl_certificate->value.len == 0
  7195.         || conf->ssl_certificate_key == NULL)
  7196.     {
  7197.         return NGX_OK;
  7198.     }

  7200.     if (conf->ssl_certificate->lengths == NULL
  7201.         && conf->ssl_certificate_key->lengths == NULL)
  7202.     {
  7203.         if (conf->ssl_passwords && conf->ssl_passwords->pool == NULL) {
  7204.             /* un-preserve empty password list */
  7205.             conf->ssl_passwords = NULL;
  7206.         }

  7208.         return NGX_OK;
  7209.     }

  7211.     if (conf->ssl_passwords && conf->ssl_passwords->pool != cf->temp_pool) {
  7212.         /* already preserved */
  7213.         return NGX_OK;
  7214.     }

  7216.     preserve = (conf->ssl_passwords == prev->ssl_passwords) ? 1 : 0;

  7218.     conf->ssl_passwords = ngx_ssl_preserve_passwords(cf, conf->ssl_passwords);
  7219.     if (conf->ssl_passwords == NULL) {
  7220.         return NGX_ERROR;
  7221.     }

  7223.     /*
  7224.      * special handling to keep a preserved ssl_passwords copy
  7225.      * in the previous configuration to inherit it to all children
  7226.      */

  7228.     if (preserve) {
  7229.         prev->ssl_passwords = conf->ssl_passwords;
  7230.     }

  7232.     return NGX_OK;
  7233. }

  7235. #endif


  7238. static void *
  7239. ‌ngx_http_upstream_create_main_conf(ngx_conf_t *cf)
  7240. {
  7241.     ngx_http_upstream_main_conf_t  *umcf;

  7243.     umcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_main_conf_t));
  7244.     if (umcf == NULL) {
  7245.         return NULL;
  7246.     }

  7248.     if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
  7249.                        sizeof(ngx_http_upstream_srv_conf_t *))
  7250.         != NGX_OK)
  7251.     {
  7252.         return NULL;
  7253.     }

  7255.     return umcf;
  7256. }


  7259. static char *
  7260. ‌ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
  7261. {
  7262.     ngx_http_upstream_main_conf_t  *umcf = conf;

  7264.     ngx_uint_t                      i;
  7265.     ngx_array_t                     headers_in;
  7266.     ngx_hash_key_t                 *hk;
  7267.     ngx_hash_init_t                 hash;
  7268.     ngx_http_upstream_init_pt       init;
  7269.     ngx_http_upstream_header_t     *header;
  7270.     ngx_http_upstream_srv_conf_t  **uscfp;

  7272.     uscfp = umcf->upstreams.elts;

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

  7276.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:
  7277.                                             ngx_http_upstream_init_round_robin;

  7279.         if (init(cf, uscfp[i]) != NGX_OK) {
  7280.             return NGX_CONF_ERROR;
  7281.         }
  7282.     }


  7285.     /* upstream_headers_in_hash */

  7287.     if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
  7288.         != NGX_OK)
  7289.     {
  7290.         return NGX_CONF_ERROR;
  7291.     }

  7293.     for (header = ngx_http_upstream_headers_in; header->name.len; header++) {
  7294.         hk = ngx_array_push(&headers_in);
  7295.         if (hk == NULL) {
  7296.             return NGX_CONF_ERROR;
  7297.         }

  7299.         hk->key = header->name;
  7300.         hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
  7301.         hk->value = header;
  7302.     }

  7304.     hash.hash = &umcf->headers_in_hash;
  7305.     hash.key = ngx_hash_key_lc;
  7306.     hash.max_size = 512;
  7307.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  7308.     hash.name = "upstream_headers_in_hash";
  7309.     hash.pool = cf->pool;
  7310.     hash.temp_pool = NULL;

  7312.     if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
  7313.         return NGX_CONF_ERROR;
  7314.     }

  7316.     return NGX_CONF_OK;
  7317. }

One Level Up Top Level