One Level Up Top Level

src/http/ngx_http_upstream.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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_process_priority(ngx_http_request_t *r,
  143.     ngx_table_elt_t *h, ngx_uint_t offset);
  144. static ngx_int_t ngx_http_upstream_copy_header_line(ngx_http_request_t *r,
  145.     ngx_table_elt_t *h, ngx_uint_t offset);
  146. static ngx_int_t
  147.     ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  148.     ngx_table_elt_t *h, ngx_uint_t offset);
  149. static ngx_int_t ngx_http_upstream_copy_content_type(ngx_http_request_t *r,
  150.     ngx_table_elt_t *h, ngx_uint_t offset);
  151. static ngx_int_t ngx_http_upstream_copy_last_modified(ngx_http_request_t *r,
  152.     ngx_table_elt_t *h, ngx_uint_t offset);
  153. static ngx_int_t ngx_http_upstream_rewrite_location(ngx_http_request_t *r,
  154.     ngx_table_elt_t *h, ngx_uint_t offset);
  155. static ngx_int_t ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r,
  156.     ngx_table_elt_t *h, ngx_uint_t offset);
  157. static ngx_int_t ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r,
  158.     ngx_table_elt_t *h, ngx_uint_t offset);
  159. static ngx_int_t ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  160.     ngx_table_elt_t *h, ngx_uint_t offset);
  161. static ngx_int_t ngx_http_upstream_copy_upgrade(ngx_http_request_t *r,
  162.     ngx_table_elt_t *h, ngx_uint_t offset);

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

  180. static char *ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy);
  181. static char *ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd,
  182.     void *conf);
  183. #if (NGX_HTTP_UPSTREAM_ZONE)
  184. static char *ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd,
  185.     void *conf);
  186. #endif

  188. static ngx_int_t ngx_http_upstream_set_local(ngx_http_request_t *r,
  189.   ngx_http_upstream_t *u, ngx_http_upstream_local_t *local);

  191. static void *ngx_http_upstream_create_main_conf(ngx_conf_t *cf);
  192. static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf);

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


  208. ‌static ngx_http_upstream_header_t  ngx_http_upstream_headers_in[] = {

  210.     { ngx_string("Status"),
  211.                  ngx_http_upstream_process_header_line,
  212.                  offsetof(ngx_http_upstream_headers_in_t, status),
  213.                  ngx_http_upstream_copy_header_line, 0, 0 },

  215.     { ngx_string("Content-Type"),
  216.                  ngx_http_upstream_process_header_line,
  217.                  offsetof(ngx_http_upstream_headers_in_t, content_type),
  218.                  ngx_http_upstream_copy_content_type, 0, 1 },

  220.     { ngx_string("Content-Length"),
  221.                  ngx_http_upstream_process_content_length, 0,
  222.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  224.     { ngx_string("Date"),
  225.                  ngx_http_upstream_process_header_line,
  226.                  offsetof(ngx_http_upstream_headers_in_t, date),
  227.                  ngx_http_upstream_copy_header_line,
  228.                  offsetof(ngx_http_headers_out_t, date), 0 },

  230.     { ngx_string("Last-Modified"),
  231.                  ngx_http_upstream_process_last_modified, 0,
  232.                  ngx_http_upstream_copy_last_modified, 0, 0 },

  234.     { ngx_string("ETag"),
  235.                  ngx_http_upstream_process_header_line,
  236.                  offsetof(ngx_http_upstream_headers_in_t, etag),
  237.                  ngx_http_upstream_copy_header_line,
  238.                  offsetof(ngx_http_headers_out_t, etag), 0 },

  240.     { ngx_string("Server"),
  241.                  ngx_http_upstream_process_header_line,
  242.                  offsetof(ngx_http_upstream_headers_in_t, server),
  243.                  ngx_http_upstream_copy_header_line,
  244.                  offsetof(ngx_http_headers_out_t, server), 0 },

  246.     { ngx_string("WWW-Authenticate"),
  247.                  ngx_http_upstream_process_multi_header_lines,
  248.                  offsetof(ngx_http_upstream_headers_in_t, www_authenticate),
  249.                  ngx_http_upstream_copy_header_line, 0, 0 },

  251.     { ngx_string("Location"),
  252.                  ngx_http_upstream_process_header_line,
  253.                  offsetof(ngx_http_upstream_headers_in_t, location),
  254.                  ngx_http_upstream_rewrite_location, 0, 0 },

  256.     { ngx_string("Refresh"),
  257.                  ngx_http_upstream_process_header_line,
  258.                  offsetof(ngx_http_upstream_headers_in_t, refresh),
  259.                  ngx_http_upstream_rewrite_refresh, 0, 0 },

  261.     { ngx_string("Set-Cookie"),
  262.                  ngx_http_upstream_process_set_cookie,
  263.                  offsetof(ngx_http_upstream_headers_in_t, set_cookie),
  264.                  ngx_http_upstream_rewrite_set_cookie, 0, 1 },

  266.     { ngx_string("Content-Disposition"),
  267.                  ngx_http_upstream_ignore_header_line, 0,
  268.                  ngx_http_upstream_copy_header_line, 0, 1 },

  270.     { ngx_string("Cache-Control"),
  271.                  ngx_http_upstream_process_cache_control, 0,
  272.                  ngx_http_upstream_copy_multi_header_lines,
  273.                  offsetof(ngx_http_headers_out_t, cache_control), 1 },

  275.     { ngx_string("Expires"),
  276.                  ngx_http_upstream_process_expires, 0,
  277.                  ngx_http_upstream_copy_header_line,
  278.                  offsetof(ngx_http_headers_out_t, expires), 1 },

  280.     { ngx_string("Accept-Ranges"),
  281.                  ngx_http_upstream_ignore_header_line, 0,
  282.                  ngx_http_upstream_copy_allow_ranges,
  283.                  offsetof(ngx_http_headers_out_t, accept_ranges), 1 },

  285.     { ngx_string("Upgrade"),
  286.                  ngx_http_upstream_ignore_header_line, 0,
  287.                  ngx_http_upstream_copy_upgrade, 0, 0 },

  289.     { ngx_string("Content-Range"),
  290.                  ngx_http_upstream_ignore_header_line, 0,
  291.                  ngx_http_upstream_copy_header_line,
  292.                  offsetof(ngx_http_headers_out_t, content_range), 0 },

  294.     { ngx_string("Connection"),
  295.                  ngx_http_upstream_process_connection, 0,
  296.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  298.     { ngx_string("Keep-Alive"),
  299.                  ngx_http_upstream_ignore_header_line, 0,
  300.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  302.     { ngx_string("Vary"),
  303.                  ngx_http_upstream_process_vary, 0,
  304.                  ngx_http_upstream_copy_header_line, 0, 0 },

  306.     { ngx_string("Link"),
  307.                  ngx_http_upstream_ignore_header_line, 0,
  308.                  ngx_http_upstream_copy_multi_header_lines,
  309.                  offsetof(ngx_http_headers_out_t, link), 0 },

  311.     { ngx_string("X-Accel-Expires"),
  312.                  ngx_http_upstream_process_accel_expires, 0,
  313.                  ngx_http_upstream_copy_header_line, 0, 0 },

  315.     { ngx_string("X-Accel-Redirect"),
  316.                  ngx_http_upstream_process_header_line,
  317.                  offsetof(ngx_http_upstream_headers_in_t, x_accel_redirect),
  318.                  ngx_http_upstream_copy_header_line, 0, 0 },

  320.     { ngx_string("X-Accel-Limit-Rate"),
  321.                  ngx_http_upstream_process_limit_rate, 0,
  322.                  ngx_http_upstream_copy_header_line, 0, 0 },

  324.     { ngx_string("X-Accel-Buffering"),
  325.                  ngx_http_upstream_process_buffering, 0,
  326.                  ngx_http_upstream_copy_header_line, 0, 0 },

  328.     { ngx_string("X-Accel-Charset"),
  329.                  ngx_http_upstream_process_charset, 0,
  330.                  ngx_http_upstream_copy_header_line, 0, 0 },

  332.     { ngx_string("Transfer-Encoding"),
  333.                  ngx_http_upstream_process_transfer_encoding, 0,
  334.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  336.     { ngx_string("Content-Encoding"),
  337.                  ngx_http_upstream_ignore_header_line, 0,
  338.                  ngx_http_upstream_copy_header_line,
  339.                  offsetof(ngx_http_headers_out_t, content_encoding), 0 },

  341.     { ngx_string("Priority"),
  342.                  ngx_http_upstream_process_priority, 0,
  343.                  ngx_http_upstream_copy_header_line, 0, 0 },

  345.     { ngx_null_string, NULL, 0, NULL, 0, 0 }
  346. };


  349. ‌static ngx_command_t  ngx_http_upstream_commands[] = {

  351.     { ngx_string("upstream"),
  352.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
  353.       ngx_http_upstream,
  354.       0,
  355.       0,
  356.       NULL },

  358.     { ngx_string("server"),
  359.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  360.       ngx_http_upstream_server,
  361.       NGX_HTTP_SRV_CONF_OFFSET,
  362.       0,
  363.       NULL },

  365. #if (NGX_HTTP_UPSTREAM_ZONE)

  367.     { ngx_string("resolver"),
  368.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  369.       ngx_http_upstream_resolver,
  370.       NGX_HTTP_SRV_CONF_OFFSET,
  371.       0,
  372.       NULL },

  374.     { ngx_string("resolver_timeout"),
  375.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  376.       ngx_conf_set_msec_slot,
  377.       NGX_HTTP_SRV_CONF_OFFSET,
  378.       offsetof(ngx_http_upstream_srv_conf_t, resolver_timeout),
  379.       NULL },

  381. #endif

  383.       ngx_null_command
  384. };


  387. ‌static ngx_http_module_t  ngx_http_upstream_module_ctx = {
  388.     ngx_http_upstream_add_variables,       /* preconfiguration */
  389.     NULL,                                  /* postconfiguration */

  391.     ngx_http_upstream_create_main_conf,    /* create main configuration */
  392.     ngx_http_upstream_init_main_conf,      /* init main configuration */

  394.     NULL,                                  /* create server configuration */
  395.     NULL,                                  /* merge server configuration */

  397.     NULL,                                  /* create location configuration */
  398.     NULL                                   /* merge location configuration */
  399. };


  402. ‌ngx_module_t  ngx_http_upstream_module = {
  403.     NGX_MODULE_V1,
  404.     &ngx_http_upstream_module_ctx,         /* module context */
  405.     ngx_http_upstream_commands,            /* module directives */
  406.     NGX_HTTP_MODULE,                       /* module type */
  407.     NULL,                                  /* init master */
  408.     NULL,                                  /* init module */
  409.     NULL,                                  /* init process */
  410.     NULL,                                  /* init thread */
  411.     NULL,                                  /* exit thread */
  412.     NULL,                                  /* exit process */
  413.     NULL,                                  /* exit master */
  414.     NGX_MODULE_V1_PADDING
  415. };


  418. ‌static ngx_http_variable_t  ngx_http_upstream_vars[] = {

  420.     { ngx_string("upstream_addr"), NULL,
  421.       ngx_http_upstream_addr_variable, 0,
  422.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  424.     { ngx_string("upstream_status"), NULL,
  425.       ngx_http_upstream_status_variable, 0,
  426.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  428.     { ngx_string("upstream_connect_time"), NULL,
  429.       ngx_http_upstream_response_time_variable, 2,
  430.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  432.     { ngx_string("upstream_header_time"), NULL,
  433.       ngx_http_upstream_response_time_variable, 1,
  434.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  436.     { ngx_string("upstream_response_time"), NULL,
  437.       ngx_http_upstream_response_time_variable, 0,
  438.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  440.     { ngx_string("upstream_response_length"), NULL,
  441.       ngx_http_upstream_response_length_variable, 0,
  442.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  444.     { ngx_string("upstream_bytes_received"), NULL,
  445.       ngx_http_upstream_response_length_variable, 1,
  446.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  448.     { ngx_string("upstream_bytes_sent"), NULL,
  449.       ngx_http_upstream_response_length_variable, 2,
  450.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  452. #if (NGX_HTTP_CACHE)

  454.     { ngx_string("upstream_cache_status"), NULL,
  455.       ngx_http_upstream_cache_status, 0,
  456.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  458.     { ngx_string("upstream_cache_last_modified"), NULL,
  459.       ngx_http_upstream_cache_last_modified, 0,
  460.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  462.     { ngx_string("upstream_cache_etag"), NULL,
  463.       ngx_http_upstream_cache_etag, 0,
  464.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  466. #endif

  468.     { ngx_string("upstream_http_"), NULL, ngx_http_upstream_header_variable,
  469.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  471.     { ngx_string("upstream_trailer_"), NULL, ngx_http_upstream_trailer_variable,
  472.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  474.     { ngx_string("upstream_cookie_"), NULL, ngx_http_upstream_cookie_variable,
  475.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  477.       ngx_http_null_variable
  478. };


  481. ‌static ngx_http_upstream_next_t  ngx_http_upstream_next_errors[] = {
  482.     { 500, NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  483.     { 502, NGX_HTTP_UPSTREAM_FT_HTTP_502 },
  484.     { 503, NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  485.     { 504, NGX_HTTP_UPSTREAM_FT_HTTP_504 },
  486.     { 403, NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  487.     { 404, NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  488.     { 429, NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  489.     { 0, 0 }
  490. };


  493. ‌ngx_conf_bitmask_t  ngx_http_upstream_cache_method_mask[] = {
  494.     { ngx_string("GET"), NGX_HTTP_GET },
  495.     { ngx_string("HEAD"), NGX_HTTP_HEAD },
  496.     { ngx_string("POST"), NGX_HTTP_POST },
  497.     { ngx_null_string, 0 }
  498. };


  501. ‌ngx_conf_bitmask_t  ngx_http_upstream_ignore_headers_masks[] = {
  502.     { ngx_string("X-Accel-Redirect"), NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT },
  503.     { ngx_string("X-Accel-Expires"), NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES },
  504.     { ngx_string("X-Accel-Limit-Rate"), NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE },
  505.     { ngx_string("X-Accel-Buffering"), NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING },
  506.     { ngx_string("X-Accel-Charset"), NGX_HTTP_UPSTREAM_IGN_XA_CHARSET },
  507.     { ngx_string("Expires"), NGX_HTTP_UPSTREAM_IGN_EXPIRES },
  508.     { ngx_string("Cache-Control"), NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL },
  509.     { ngx_string("Set-Cookie"), NGX_HTTP_UPSTREAM_IGN_SET_COOKIE },
  510.     { ngx_string("Vary"), NGX_HTTP_UPSTREAM_IGN_VARY },
  511.     { ngx_null_string, 0 }
  512. };


  515. ngx_int_t
  516. ‌ngx_http_upstream_create(ngx_http_request_t *r)
  517. {
  518.     ngx_http_upstream_t  *u;

  520.     u = r->upstream;

  522.     if (u && u->cleanup) {
  523.         r->main->count++;
  524.         ngx_http_upstream_cleanup(r);
  525.     }

  527.     u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
  528.     if (u == NULL) {
  529.         return NGX_ERROR;
  530.     }

  532.     r->upstream = u;

  534.     u->peer.log = r->connection->log;
  535.     u->peer.log_error = NGX_ERROR_ERR;

  537. #if (NGX_HTTP_CACHE)
  538.     r->cache = NULL;
  539. #endif

  541.     u->headers_in.content_length_n = -1;
  542.     u->headers_in.last_modified_time = -1;

  544.     return NGX_OK;
  545. }


  548. void
  549. ‌ngx_http_upstream_init(ngx_http_request_t *r)
  550. {
  551.     ngx_connection_t     *c;

  553.     c = r->connection;

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

  558. #if (NGX_HTTP_V2)
  559.     if (r->stream) {
  560.         ngx_http_upstream_init_request(r);
  561.         return;
  562.     }
  563. #endif

  565. #if (NGX_HTTP_V3)
  566.     if (c->quic) {
  567.         ngx_http_upstream_init_request(r);
  568.         return;
  569.     }
  570. #endif

  572.     if (c->read->timer_set) {
  573.         ngx_del_timer(c->read);
  574.     }

  576.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  578.         if (!c->write->active) {
  579.             if (ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT)
  580.                 == NGX_ERROR)
  581.             {
  582.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  583.                 return;
  584.             }
  585.         }
  586.     }

  588.     ngx_http_upstream_init_request(r);
  589. }


  592. static void
  593. ‌ngx_http_upstream_init_request(ngx_http_request_t *r)
  594. {
  595.     ngx_str_t                      *host;
  596.     ngx_uint_t                      i;
  597.     ngx_resolver_ctx_t             *ctx, temp;
  598.     ngx_http_cleanup_t             *cln;
  599.     ngx_http_upstream_t            *u;
  600.     ngx_http_core_loc_conf_t       *clcf;
  601.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  602.     ngx_http_upstream_main_conf_t  *umcf;

  604.     if (r->aio) {
  605.         return;
  606.     }

  608.     u = r->upstream;

  610. #if (NGX_HTTP_CACHE)

  612.     if (u->conf->cache) {
  613.         ngx_int_t  rc;

  615.         rc = ngx_http_upstream_cache(r, u);

  617.         if (rc == NGX_BUSY) {
  618.             r->write_event_handler = ngx_http_upstream_init_request;
  619.             return;
  620.         }

  622.         r->write_event_handler = ngx_http_request_empty_handler;

  624.         if (rc == NGX_ERROR) {
  625.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  626.             return;
  627.         }

  629.         if (rc == NGX_OK) {
  630.             rc = ngx_http_upstream_cache_send(r, u);

  632.             if (rc == NGX_DONE) {
  633.                 return;
  634.             }

  636.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  637.                 rc = NGX_DECLINED;
  638.                 r->cached = 0;
  639.                 u->buffer.start = NULL;
  640.                 u->cache_status = NGX_HTTP_CACHE_MISS;
  641.                 u->request_sent = 1;
  642.             }
  643.         }

  645.         if (rc != NGX_DECLINED) {
  646.             ngx_http_finalize_request(r, rc);
  647.             return;
  648.         }
  649.     }

  651. #endif

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

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

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

  660.         } else {
  661.             if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  662.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  663.                 return;
  664.             }
  665.         }

  667.         r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;
  668.         r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
  669.     }

  671.     if (r->request_body) {
  672.         u->request_bufs = r->request_body->bufs;
  673.     }

  675.     if (u->create_request(r) != NGX_OK) {
  676.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  677.         return;
  678.     }

  680.     if (ngx_http_upstream_set_local(r, u, u->conf->local) != NGX_OK) {
  681.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  682.         return;
  683.     }

  685.     if (u->conf->socket_keepalive) {
  686.         u->peer.so_keepalive = 1;
  687.     }

  689.     if (u->conf->socket_rcvbuf) {
  690.         u->peer.rcvbuf = (int) u->conf->socket_rcvbuf;
  691.     }

  693.     if (u->conf->socket_sndbuf) {
  694.         u->peer.sndbuf = (int) u->conf->socket_sndbuf;
  695.     }

  697.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  699.     u->output.alignment = clcf->directio_alignment;
  700.     u->output.pool = r->pool;
  701.     u->output.bufs.num = 1;
  702.     u->output.bufs.size = clcf->client_body_buffer_size;

  704.     if (u->output.output_filter == NULL) {
  705.         u->output.output_filter = ngx_chain_writer;
  706.         u->output.filter_ctx = &u->writer;
  707.     }

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

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

  713.         r->upstream_states = ngx_array_create(r->pool, 1,
  714.                                             sizeof(ngx_http_upstream_state_t));
  715.         if (r->upstream_states == NULL) {
  716.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  717.             return;
  718.         }

  720.     } else {

  722.         u->state = ngx_array_push(r->upstream_states);
  723.         if (u->state == NULL) {
  724.             ngx_http_upstream_finalize_request(r, u,
  725.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  726.             return;
  727.         }

  729.         ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
  730.     }

  732.     cln = ngx_http_cleanup_add(r, 0);
  733.     if (cln == NULL) {
  734.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  735.         return;
  736.     }

  738.     cln->handler = ngx_http_upstream_cleanup;
  739.     cln->data = r;
  740.     u->cleanup = &cln->handler;

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

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

  746.     } else {

  748. #if (NGX_HTTP_SSL)
  749.         u->ssl_name = u->resolved->host;
  750. #endif

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

  754.         umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  756.         uscfp = umcf->upstreams.elts;

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

  760.             uscf = uscfp[i];

  762.             if (uscf->host.len == host->len
  763.                 && ((uscf->port == 0 && u->resolved->no_port)
  764.                      || uscf->port == u->resolved->port)
  765.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  766.             {
  767.                 goto found;
  768.             }
  769.         }

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

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

  783.             if (ngx_http_upstream_create_round_robin_peer(r, u->resolved)
  784.                 != NGX_OK)
  785.             {
  786.                 ngx_http_upstream_finalize_request(r, u,
  787.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  788.                 return;
  789.             }

  791.             ngx_http_upstream_connect(r, u);

  793.             return;
  794.         }

  796.         if (u->resolved->port == 0) {
  797.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  798.                           "no port in upstream \"%V\"", host);
  799.             ngx_http_upstream_finalize_request(r, u,
  800.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  801.             return;
  802.         }

  804.         temp.name = *host;

  806.         ctx = ngx_resolve_start(clcf->resolver, &temp);
  807.         if (ctx == NULL) {
  808.             ngx_http_upstream_finalize_request(r, u,
  809.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  810.             return;
  811.         }

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

  817.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  818.             return;
  819.         }

  821.         ctx->name = *host;
  822.         ctx->handler = ngx_http_upstream_resolve_handler;
  823.         ctx->data = r;
  824.         ctx->timeout = clcf->resolver_timeout;

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

  828.         if (ngx_resolve_name(ctx) != NGX_OK) {
  829.             u->resolved->ctx = NULL;
  830.             ngx_http_upstream_finalize_request(r, u,
  831.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  832.             return;
  833.         }

  835.         return;
  836.     }

  838. found:

  840.     if (uscf == NULL) {
  841.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  842.                       "no upstream configuration");
  843.         ngx_http_upstream_finalize_request(r, u,
  844.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  845.         return;
  846.     }

  848.     u->upstream = uscf;

  850. #if (NGX_HTTP_SSL)
  851.     u->ssl_name = uscf->host;
  852. #endif

  854.     if (uscf->peer.init(r, uscf) != NGX_OK) {
  855.         ngx_http_upstream_finalize_request(r, u,
  856.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  857.         return;
  858.     }

  860.     u->peer.start_time = ngx_current_msec;

  862.     if (u->conf->next_upstream_tries
  863.         && u->peer.tries > u->conf->next_upstream_tries)
  864.     {
  865.         u->peer.tries = u->conf->next_upstream_tries;
  866.     }

  868.     ngx_http_upstream_connect(r, u);
  869. }


  872. #if (NGX_HTTP_CACHE)

  874. static ngx_int_t
  875. ‌ngx_http_upstream_cache(ngx_http_request_t *r, ngx_http_upstream_t *u)
  876. {
  877.     ngx_int_t               rc;
  878.     ngx_http_cache_t       *c;
  879.     ngx_http_file_cache_t  *cache;

  881.     c = r->cache;

  883.     if (c == NULL) {

  885.         if (!(r->method & u->conf->cache_methods)) {
  886.             return NGX_DECLINED;
  887.         }

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

  891.         if (rc != NGX_OK) {
  892.             return rc;
  893.         }

  895.         if (r->method == NGX_HTTP_HEAD && u->conf->cache_convert_head) {
  896.             u->method = ngx_http_core_get_method;
  897.         }

  899.         if (ngx_http_file_cache_new(r) != NGX_OK) {
  900.             return NGX_ERROR;
  901.         }

  903.         if (u->create_key(r) != NGX_OK) {
  904.             return NGX_ERROR;
  905.         }

  907.         /* TODO: add keys */

  909.         ngx_http_file_cache_create_key(r);

  911.         if (r->cache->header_start + 256 > u->conf->buffer_size) {
  912.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  913.                           "%V_buffer_size %uz is not enough for cache key, "
  914.                           "it should be increased to at least %uz",
  915.                           &u->conf->module, u->conf->buffer_size,
  916.                           ngx_align(r->cache->header_start + 256, 1024));

  918.             r->cache = NULL;
  919.             return NGX_DECLINED;
  920.         }

  922.         u->cacheable = 1;

  924.         c = r->cache;

  926.         c->body_start = u->conf->buffer_size;
  927.         c->min_uses = u->conf->cache_min_uses;
  928.         c->file_cache = cache;

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

  932.         case NGX_ERROR:
  933.             return NGX_ERROR;

  935.         case NGX_DECLINED:
  936.             u->cache_status = NGX_HTTP_CACHE_BYPASS;
  937.             return NGX_DECLINED;

  939.         default: /* NGX_OK */
  940.             break;
  941.         }

  943.         c->lock = u->conf->cache_lock;
  944.         c->lock_timeout = u->conf->cache_lock_timeout;
  945.         c->lock_age = u->conf->cache_lock_age;

  947.         u->cache_status = NGX_HTTP_CACHE_MISS;
  948.     }

  950.     rc = ngx_http_file_cache_open(r);

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

  955.     switch (rc) {

  957.     case NGX_HTTP_CACHE_STALE:

  959.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  960.              || c->stale_updating) && !r->background
  961.             && u->conf->cache_background_update)
  962.         {
  963.             if (ngx_http_upstream_cache_background_update(r, u) == NGX_OK) {
  964.                 r->cache->background = 1;
  965.                 u->cache_status = rc;
  966.                 rc = NGX_OK;

  968.             } else {
  969.                 rc = NGX_ERROR;
  970.             }
  971.         }

  973.         break;

  975.     case NGX_HTTP_CACHE_UPDATING:

  977.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  978.              || c->stale_updating) && !r->background)
  979.         {
  980.             u->cache_status = rc;
  981.             rc = NGX_OK;

  983.         } else {
  984.             rc = NGX_HTTP_CACHE_STALE;
  985.         }

  987.         break;

  989.     case NGX_OK:
  990.         u->cache_status = NGX_HTTP_CACHE_HIT;
  991.     }

  993.     switch (rc) {

  995.     case NGX_OK:

  997.         return NGX_OK;

  999.     case NGX_HTTP_CACHE_STALE:

  1001.         c->valid_sec = 0;
  1002.         c->updating_sec = 0;
  1003.         c->error_sec = 0;

  1005.         u->buffer.start = NULL;
  1006.         u->cache_status = NGX_HTTP_CACHE_EXPIRED;

  1008.         break;

  1010.     case NGX_DECLINED:

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

  1015.         } else {
  1016.             u->buffer.pos = u->buffer.start + c->header_start;
  1017.             u->buffer.last = u->buffer.pos;
  1018.         }

  1020.         break;

  1022.     case NGX_HTTP_CACHE_SCARCE:

  1024.         u->cacheable = 0;

  1026.         break;

  1028.     case NGX_AGAIN:

  1030.         return NGX_BUSY;

  1032.     case NGX_ERROR:

  1034.         return NGX_ERROR;

  1036.     default:

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

  1040.         u->cache_status = NGX_HTTP_CACHE_HIT;

  1042.         return rc;
  1043.     }

  1045.     if (ngx_http_upstream_cache_check_range(r, u) == NGX_DECLINED) {
  1046.         u->cacheable = 0;
  1047.     }

  1049.     r->cached = 0;

  1051.     return NGX_DECLINED;
  1052. }


  1055. static ngx_int_t
  1056. ‌ngx_http_upstream_cache_get(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1057.     ngx_http_file_cache_t **cache)
  1058. {
  1059.     ngx_str_t               *name, val;
  1060.     ngx_uint_t               i;
  1061.     ngx_http_file_cache_t  **caches;

  1063.     if (u->conf->cache_zone) {
  1064.         *cache = u->conf->cache_zone->data;
  1065.         return NGX_OK;
  1066.     }

  1068.     if (ngx_http_complex_value(r, u->conf->cache_value, &val) != NGX_OK) {
  1069.         return NGX_ERROR;
  1070.     }

  1072.     if (val.len == 0
  1073.         || (val.len == 3 && ngx_strncmp(val.data, "off", 3) == 0))
  1074.     {
  1075.         return NGX_DECLINED;
  1076.     }

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

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

  1083.         if (name->len == val.len
  1084.             && ngx_strncmp(name->data, val.data, val.len) == 0)
  1085.         {
  1086.             *cache = caches[i];
  1087.             return NGX_OK;
  1088.         }
  1089.     }

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

  1094.     return NGX_ERROR;
  1095. }


  1098. static ngx_int_t
  1099. ‌ngx_http_upstream_cache_send(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1100. {
  1101.     ngx_int_t          rc;
  1102.     ngx_http_cache_t  *c;

  1104.     r->cached = 1;
  1105.     c = r->cache;

  1107.     if (c->header_start == c->body_start) {
  1108.         r->http_version = NGX_HTTP_VERSION_9;
  1109.         return ngx_http_cache_send(r);
  1110.     }

  1112.     /* TODO: cache stack */

  1114.     u->buffer = *c->buf;
  1115.     u->buffer.pos += c->header_start;

  1117.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  1118.     u->headers_in.content_length_n = -1;
  1119.     u->headers_in.last_modified_time = -1;

  1121.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  1122.                       sizeof(ngx_table_elt_t))
  1123.         != NGX_OK)
  1124.     {
  1125.         return NGX_ERROR;
  1126.     }

  1128.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  1129.                       sizeof(ngx_table_elt_t))
  1130.         != NGX_OK)
  1131.     {
  1132.         return NGX_ERROR;
  1133.     }

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

  1137.     if (rc == NGX_OK) {

  1139.         rc = ngx_http_upstream_process_headers(r, u);

  1141.         if (rc != NGX_OK) {
  1142.             return rc;
  1143.         }

  1145.         return ngx_http_cache_send(r);
  1146.     }

  1148.     if (rc == NGX_ERROR) {
  1149.         return NGX_ERROR;
  1150.     }

  1152.     if (rc == NGX_AGAIN || rc == NGX_HTTP_UPSTREAM_EARLY_HINTS) {
  1153.         rc = NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1154.     }

  1156.     /* rc == NGX_HTTP_UPSTREAM_INVALID_HEADER */

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

  1162.     /* TODO: delete file */

  1164.     return rc;
  1165. }


  1168. static ngx_int_t
  1169. ‌ngx_http_upstream_cache_background_update(ngx_http_request_t *r,
  1170.     ngx_http_upstream_t *u)
  1171. {
  1172.     ngx_http_request_t  *sr;

  1174.     if (r == r->main) {
  1175.         r->preserve_body = 1;
  1176.     }

  1178.     if (ngx_http_subrequest(r, &r->uri, &r->args, &sr, NULL,
  1179.                             NGX_HTTP_SUBREQUEST_CLONE
  1180.                             |NGX_HTTP_SUBREQUEST_BACKGROUND)
  1181.         != NGX_OK)
  1182.     {
  1183.         return NGX_ERROR;
  1184.     }

  1186.     sr->header_only = 1;

  1188.     return NGX_OK;
  1189. }


  1192. static ngx_int_t
  1193. ‌ngx_http_upstream_cache_check_range(ngx_http_request_t *r,
  1194.     ngx_http_upstream_t *u)
  1195. {
  1196.     off_t             offset;
  1197.     u_char           *p, *start;
  1198.     ngx_table_elt_t  *h;

  1200.     h = r->headers_in.range;

  1202.     if (h == NULL
  1203.         || !u->cacheable
  1204.         || u->conf->cache_max_range_offset == NGX_MAX_OFF_T_VALUE)
  1205.     {
  1206.         return NGX_OK;
  1207.     }

  1209.     if (u->conf->cache_max_range_offset == 0) {
  1210.         return NGX_DECLINED;
  1211.     }

  1213.     if (h->value.len < 7
  1214.         || ngx_strncasecmp(h->value.data, (u_char *) "bytes=", 6) != 0)
  1215.     {
  1216.         return NGX_OK;
  1217.     }

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

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

  1223.     if (*p == '-') {
  1224.         return NGX_DECLINED;
  1225.     }

  1227.     start = p;

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

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

  1233.     if (offset >= u->conf->cache_max_range_offset) {
  1234.         return NGX_DECLINED;
  1235.     }

  1237.     return NGX_OK;
  1238. }

  1240. #endif


  1243. static void
  1244. ‌ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
  1245. {
  1246.     ngx_uint_t                     run_posted;
  1247.     ngx_connection_t              *c;
  1248.     ngx_http_request_t            *r;
  1249.     ngx_http_upstream_t           *u;
  1250.     ngx_http_upstream_resolved_t  *ur;

  1252.     run_posted = ctx->async;

  1254.     r = ctx->data;
  1255.     c = r->connection;

  1257.     u = r->upstream;
  1258.     ur = u->resolved;

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

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

  1265.     if (ctx->state) {
  1266.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1267.                       "%V could not be resolved (%i: %s)",
  1268.                       &ctx->name, ctx->state,
  1269.                       ngx_resolver_strerror(ctx->state));

  1271.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  1272.         goto failed;
  1273.     }

  1275.     ur->naddrs = ctx->naddrs;
  1276.     ur->addrs = ctx->addrs;

  1278. #if (NGX_DEBUG)
  1279.     {
  1280.     u_char      text[NGX_SOCKADDR_STRLEN];
  1281.     ngx_str_t   addr;
  1282.     ngx_uint_t  i;

  1284.     addr.data = text;

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

  1290.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1291.                        "name was resolved to %V", &addr);
  1292.     }
  1293.     }
  1294. #endif

  1296.     if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
  1297.         ngx_http_upstream_finalize_request(r, u,
  1298.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1299.         goto failed;
  1300.     }

  1302.     ngx_resolve_name_done(ctx);
  1303.     ur->ctx = NULL;

  1305.     u->peer.start_time = ngx_current_msec;

  1307.     if (u->conf->next_upstream_tries
  1308.         && u->peer.tries > u->conf->next_upstream_tries)
  1309.     {
  1310.         u->peer.tries = u->conf->next_upstream_tries;
  1311.     }

  1313.     ngx_http_upstream_connect(r, u);

  1315. failed:

  1317.     if (run_posted) {
  1318.         ngx_http_run_posted_requests(c);
  1319.     }
  1320. }


  1323. static void
  1324. ‌ngx_http_upstream_handler(ngx_event_t *ev)
  1325. {
  1326.     ngx_connection_t     *c;
  1327.     ngx_http_request_t   *r;
  1328.     ngx_http_upstream_t  *u;

  1330.     c = ev->data;
  1331.     r = c->data;

  1333.     u = r->upstream;
  1334.     c = r->connection;

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

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

  1341.     if (ev->delayed && ev->timedout) {
  1342.         ev->delayed = 0;
  1343.         ev->timedout = 0;
  1344.     }

  1346.     if (ev->write) {
  1347.         u->write_event_handler(r, u);

  1349.     } else {
  1350.         u->read_event_handler(r, u);
  1351.     }

  1353.     ngx_http_run_posted_requests(c);
  1354. }


  1357. static void
  1358. ‌ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r)
  1359. {
  1360.     ngx_http_upstream_check_broken_connection(r, r->connection->read);
  1361. }


  1364. static void
  1365. ‌ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r)
  1366. {
  1367.     ngx_http_upstream_check_broken_connection(r, r->connection->write);
  1368. }


  1371. static void
  1372. ‌ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  1373.     ngx_event_t *ev)
  1374. {
  1375.     int                  n;
  1376.     char                 buf[1];
  1377.     ngx_err_t            err;
  1378.     ngx_int_t            event;
  1379.     ngx_connection_t     *c;
  1380.     ngx_http_upstream_t  *u;

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

  1386.     c = r->connection;
  1387.     u = r->upstream;

  1389.     if (c->error) {
  1390.         if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {

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

  1394.             if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1395.                 ngx_http_upstream_finalize_request(r, u,
  1396.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1397.                 return;
  1398.             }
  1399.         }

  1401.         if (!u->cacheable) {
  1402.             ngx_http_upstream_finalize_request(r, u,
  1403.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1404.         }

  1406.         return;
  1407.     }

  1409. #if (NGX_HTTP_V2)
  1410.     if (r->stream) {
  1411.         return;
  1412.     }
  1413. #endif

  1415. #if (NGX_HTTP_V3)

  1417.     if (c->quic) {
  1418.         if (c->write->error) {
  1419.             ngx_http_upstream_finalize_request(r, u,
  1420.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1421.         }

  1423.         return;
  1424.     }

  1426. #endif

  1428. #if (NGX_HAVE_KQUEUE)

  1430.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  1432.         if (!ev->pending_eof) {
  1433.             return;
  1434.         }

  1436.         ev->eof = 1;
  1437.         c->error = 1;

  1439.         if (ev->kq_errno) {
  1440.             ev->error = 1;
  1441.         }

  1443.         if (!u->cacheable && u->peer.connection) {
  1444.             ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1445.                           "kevent() reported that client prematurely closed "
  1446.                           "connection, so upstream connection is closed too");
  1447.             ngx_http_upstream_finalize_request(r, u,
  1448.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1449.             return;
  1450.         }

  1452.         ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1453.                       "kevent() reported that client prematurely closed "
  1454.                       "connection");

  1456.         if (u->peer.connection == NULL) {
  1457.             ngx_http_upstream_finalize_request(r, u,
  1458.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1459.         }

  1461.         return;
  1462.     }

  1464. #endif

  1466. #if (NGX_HAVE_EPOLLRDHUP)

  1468.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  1469.         socklen_t  len;

  1471.         if (!ev->pending_eof) {
  1472.             return;
  1473.         }

  1475.         ev->eof = 1;
  1476.         c->error = 1;

  1478.         err = 0;
  1479.         len = sizeof(ngx_err_t);

  1481.         /*
  1482.          * BSDs and Linux return 0 and set a pending error in err
  1483.          * Solaris returns -1 and sets errno
  1484.          */

  1486.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1487.             == -1)
  1488.         {
  1489.             err = ngx_socket_errno;
  1490.         }

  1492.         if (err) {
  1493.             ev->error = 1;
  1494.         }

  1496.         if (!u->cacheable && u->peer.connection) {
  1497.             ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1498.                         "epoll_wait() reported that client prematurely closed "
  1499.                         "connection, so upstream connection is closed too");
  1500.             ngx_http_upstream_finalize_request(r, u,
  1501.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1502.             return;
  1503.         }

  1505.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1506.                       "epoll_wait() reported that client prematurely closed "
  1507.                       "connection");

  1509.         if (u->peer.connection == NULL) {
  1510.             ngx_http_upstream_finalize_request(r, u,
  1511.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1512.         }

  1514.         return;
  1515.     }

  1517. #endif

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

  1521.     err = ngx_socket_errno;

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

  1526.     if (ev->write && (n >= 0 || err == NGX_EAGAIN)) {
  1527.         return;
  1528.     }

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

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

  1534.         if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1535.             ngx_http_upstream_finalize_request(r, u,
  1536.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1537.             return;
  1538.         }
  1539.     }

  1541.     if (n > 0) {
  1542.         return;
  1543.     }

  1545.     if (n == -1) {
  1546.         if (err == NGX_EAGAIN) {
  1547.             return;
  1548.         }

  1550.         ev->error = 1;

  1552.     } else { /* n == 0 */
  1553.         err = 0;
  1554.     }

  1556.     ev->eof = 1;
  1557.     c->error = 1;

  1559.     if (!u->cacheable && u->peer.connection) {
  1560.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1561.                       "client prematurely closed connection, "
  1562.                       "so upstream connection is closed too");
  1563.         ngx_http_upstream_finalize_request(r, u,
  1564.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1565.         return;
  1566.     }

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

  1571.     if (u->peer.connection == NULL) {
  1572.         ngx_http_upstream_finalize_request(r, u,
  1573.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1574.     }
  1575. }


  1578. static void
  1579. ‌ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1580. {
  1581.     ngx_int_t                  rc;
  1582.     ngx_connection_t          *c;
  1583.     ngx_http_core_loc_conf_t  *clcf;

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

  1587.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  1588.         u->state->response_time = ngx_current_msec - u->start_time;
  1589.     }

  1591.     u->state = ngx_array_push(r->upstream_states);
  1592.     if (u->state == NULL) {
  1593.         ngx_http_upstream_finalize_request(r, u,
  1594.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1595.         return;
  1596.     }

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

  1600.     u->start_time = ngx_current_msec;

  1602.     u->state->response_time = (ngx_msec_t) -1;
  1603.     u->state->connect_time = (ngx_msec_t) -1;
  1604.     u->state->header_time = (ngx_msec_t) -1;

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

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

  1611.     if (rc == NGX_ERROR) {
  1612.         ngx_http_upstream_finalize_request(r, u,
  1613.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1614.         return;
  1615.     }

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

  1619. #if (NGX_HTTP_UPSTREAM_ZONE)
  1620.     if (u->upstream && u->upstream->shm_zone
  1621.         && (u->upstream->flags & NGX_HTTP_UPSTREAM_MODIFY))
  1622.     {
  1623.         u->state->peer = ngx_palloc(r->pool,
  1624.                                     sizeof(ngx_str_t) + u->peer.name->len);
  1625.         if (u->state->peer == NULL) {
  1626.             ngx_http_upstream_finalize_request(r, u,
  1627.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1628.             return;
  1629.         }

  1631.         u->state->peer->len = u->peer.name->len;
  1632.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  1633.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  1635.         u->peer.name = u->state->peer;
  1636.     }
  1637. #endif

  1639.     if (rc == NGX_BUSY) {
  1640.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
  1641.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);
  1642.         return;
  1643.     }

  1645.     if (rc == NGX_DECLINED) {
  1646.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1647.         return;
  1648.     }

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

  1652.     c = u->peer.connection;

  1654.     c->requests++;

  1656.     c->data = r;

  1658.     c->write->handler = ngx_http_upstream_handler;
  1659.     c->read->handler = ngx_http_upstream_handler;

  1661.     u->write_event_handler = ngx_http_upstream_send_request_handler;
  1662.     u->read_event_handler = ngx_http_upstream_process_header;

  1664.     c->sendfile &= r->connection->sendfile;
  1665.     u->output.sendfile = c->sendfile;

  1667.     if (r->connection->tcp_nopush == NGX_TCP_NOPUSH_DISABLED) {
  1668.         c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1669.     }

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

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

  1675.         c->pool = ngx_create_pool(128, r->connection->log);
  1676.         if (c->pool == NULL) {
  1677.             ngx_http_upstream_finalize_request(r, u,
  1678.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1679.             return;
  1680.         }
  1681.     }

  1683.     c->log = r->connection->log;
  1684.     c->pool->log = c->log;
  1685.     c->read->log = c->log;
  1686.     c->write->log = c->log;

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

  1690.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1692.     u->writer.out = NULL;
  1693.     u->writer.last = &u->writer.out;
  1694.     u->writer.connection = c;
  1695.     u->writer.limit = clcf->sendfile_max_chunk;

  1697.     if (u->request_sent || u->response_received) {
  1698.         if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
  1699.             ngx_http_upstream_finalize_request(r, u,
  1700.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1701.             return;
  1702.         }
  1703.     }

  1705.     if (r->request_body
  1706.         && r->request_body->buf
  1707.         && r->request_body->temp_file
  1708.         && r == r->main)
  1709.     {
  1710.         /*
  1711.          * the r->request_body->buf can be reused for one request only,
  1712.          * the subrequests should allocate their own temporary bufs
  1713.          */

  1715.         u->output.free = ngx_alloc_chain_link(r->pool);
  1716.         if (u->output.free == NULL) {
  1717.             ngx_http_upstream_finalize_request(r, u,
  1718.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1719.             return;
  1720.         }

  1722.         u->output.free->buf = r->request_body->buf;
  1723.         u->output.free->next = NULL;
  1724.         u->output.allocated = 1;

  1726.         r->request_body->buf->pos = r->request_body->buf->start;
  1727.         r->request_body->buf->last = r->request_body->buf->start;
  1728.         r->request_body->buf->tag = u->output.tag;
  1729.     }

  1731.     u->request_sent = 0;
  1732.     u->request_body_sent = 0;
  1733.     u->request_body_blocked = 0;
  1734.     u->response_received = 0;

  1736.     if (rc == NGX_AGAIN) {
  1737.         ngx_add_timer(c->write, u->conf->connect_timeout);
  1738.         return;
  1739.     }

  1741. #if (NGX_HTTP_SSL)

  1743.     if (u->ssl && c->ssl == NULL) {
  1744.         ngx_http_upstream_ssl_init_connection(r, u, c);
  1745.         return;
  1746.     }

  1748. #endif

  1750.     ngx_http_upstream_send_request(r, u, 1);
  1751. }


  1754. #if (NGX_HTTP_SSL)

  1756. static void
  1757. ‌ngx_http_upstream_ssl_init_connection(ngx_http_request_t *r,
  1758.     ngx_http_upstream_t *u, ngx_connection_t *c)
  1759. {
  1760.     ngx_int_t                  rc;
  1761.     ngx_http_core_loc_conf_t  *clcf;

  1763.     if (ngx_http_upstream_test_connect(c) != NGX_OK) {
  1764.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1765.         return;
  1766.     }

  1768.     if (ngx_ssl_create_connection(u->conf->ssl, c,
  1769.                                   NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1770.         != NGX_OK)
  1771.     {
  1772.         ngx_http_upstream_finalize_request(r, u,
  1773.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1774.         return;
  1775.     }

  1777.     if (u->conf->ssl_server_name || u->conf->ssl_verify) {
  1778.         if (ngx_http_upstream_ssl_name(r, u, c) != NGX_OK) {
  1779.             ngx_http_upstream_finalize_request(r, u,
  1780.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1781.             return;
  1782.         }
  1783.     }

  1785.     if (u->conf->ssl_certificate
  1786.         && u->conf->ssl_certificate->value.len
  1787.         && (u->conf->ssl_certificate->lengths
  1788.             || u->conf->ssl_certificate_key->lengths))
  1789.     {
  1790.         if (ngx_http_upstream_ssl_certificate(r, u, c) != NGX_OK) {
  1791.             ngx_http_upstream_finalize_request(r, u,
  1792.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1793.             return;
  1794.         }
  1795.     }

  1797. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1799.     if (u->ssl_alpn_protocol.len) {
  1800.         if (SSL_set_alpn_protos(c->ssl->connection, u->ssl_alpn_protocol.data,
  1801.                                 u->ssl_alpn_protocol.len)
  1802.             != 0)
  1803.         {
  1804.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  1805.                           "SSL_set_alpn_protos() failed");
  1806.             ngx_http_upstream_finalize_request(r, u,
  1807.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1808.             return;
  1809.         }
  1810.     }

  1812. #endif

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

  1817.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1818.             ngx_http_upstream_finalize_request(r, u,
  1819.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1820.             return;
  1821.         }

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

  1825.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1827.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  1828.             ngx_http_upstream_finalize_request(r, u,
  1829.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1830.             return;
  1831.         }
  1832.     }

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

  1836.     rc = ngx_ssl_handshake(c);

  1838.     if (rc == NGX_AGAIN) {

  1840.         if (!c->write->timer_set) {
  1841.             ngx_add_timer(c->write, u->conf->connect_timeout);
  1842.         }

  1844.         c->ssl->handler = ngx_http_upstream_ssl_handshake_handler;
  1845.         return;
  1846.     }

  1848.     ngx_http_upstream_ssl_handshake(r, u, c);
  1849. }


  1852. static void
  1853. ‌ngx_http_upstream_ssl_handshake_handler(ngx_connection_t *c)
  1854. {
  1855.     ngx_http_request_t   *r;
  1856.     ngx_http_upstream_t  *u;

  1858.     r = c->data;

  1860.     u = r->upstream;
  1861.     c = r->connection;

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

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

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

  1871.     ngx_http_run_posted_requests(c);
  1872. }


  1875. static void
  1876. ‌ngx_http_upstream_ssl_handshake(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1877.     ngx_connection_t *c)
  1878. {
  1879.     long  rc;

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

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

  1886.             if (rc != X509_V_OK) {
  1887.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1888.                               "upstream SSL certificate verify error: (%l:%s)",
  1889.                               rc, X509_verify_cert_error_string(rc));
  1890.                 goto failed;
  1891.             }

  1893.             if (ngx_ssl_check_host(c, &u->ssl_name) != NGX_OK) {
  1894.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1895.                               "upstream SSL certificate does not match \"%V\"",
  1896.                               &u->ssl_name);
  1897.                 goto failed;
  1898.             }
  1899.         }

  1901.         if (!c->ssl->sendfile) {
  1902.             c->sendfile = 0;
  1903.             u->output.sendfile = 0;
  1904.         }

  1906.         c->write->handler = ngx_http_upstream_handler;
  1907.         c->read->handler = ngx_http_upstream_handler;

  1909.         ngx_http_upstream_send_request(r, u, 1);

  1911.         return;
  1912.     }

  1914.     if (c->write->timedout) {
  1915.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  1916.         return;
  1917.     }

  1919. failed:

  1921.     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1922. }


  1925. static void
  1926. ‌ngx_http_upstream_ssl_save_session(ngx_connection_t *c)
  1927. {
  1928.     ngx_http_request_t   *r;
  1929.     ngx_http_upstream_t  *u;

  1931.     if (c->idle) {
  1932.         return;
  1933.     }

  1935.     r = c->data;

  1937.     u = r->upstream;
  1938.     c = r->connection;

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

  1942.     u->peer.save_session(&u->peer, u->peer.data);
  1943. }


  1946. static ngx_int_t
  1947. ‌ngx_http_upstream_ssl_name(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1948.     ngx_connection_t *c)
  1949. {
  1950.     u_char     *p, *last;
  1951.     ngx_str_t   name;

  1953.     if (u->conf->ssl_name) {
  1954.         if (ngx_http_complex_value(r, u->conf->ssl_name, &name) != NGX_OK) {
  1955.             return NGX_ERROR;
  1956.         }

  1958.     } else {
  1959.         name = u->ssl_name;
  1960.     }

  1962.     if (name.len == 0) {
  1963.         goto done;
  1964.     }

  1966.     /*
  1967.      * ssl name here may contain port, notably if derived from $proxy_host
  1968.      * or $http_host; we have to strip it
  1969.      */

  1971.     p = name.data;
  1972.     last = name.data + name.len;

  1974.     if (*p == '[') {
  1975.         p = ngx_strlchr(p, last, ']');

  1977.         if (p == NULL) {
  1978.             p = name.data;
  1979.         }
  1980.     }

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

  1984.     if (p != NULL) {
  1985.         name.len = p - name.data;
  1986.     }

  1988.     if (!u->conf->ssl_server_name) {
  1989.         goto done;
  1990.     }

  1992. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  1996.     if (name.len == 0 || *name.data == '[') {
  1997.         goto done;
  1998.     }

  2000.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  2001.         goto done;
  2002.     }

  2004.     /*
  2005.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  2006.      * hence we explicitly null-terminate name here
  2007.      */

  2009.     p = ngx_pnalloc(r->pool, name.len + 1);
  2010.     if (p == NULL) {
  2011.         return NGX_ERROR;
  2012.     }

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

  2016.     name.data = p;

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

  2021.     if (SSL_set_tlsext_host_name(c->ssl->connection,
  2022.                                  (char *) name.data)
  2023.         == 0)
  2024.     {
  2025.         ngx_ssl_error(NGX_LOG_ERR, r->connection->log, 0,
  2026.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  2027.         return NGX_ERROR;
  2028.     }

  2030. #endif

  2032. done:

  2034.     u->ssl_name = name;

  2036.     return NGX_OK;
  2037. }


  2040. static ngx_int_t
  2041. ‌ngx_http_upstream_ssl_certificate(ngx_http_request_t *r,
  2042.     ngx_http_upstream_t *u, ngx_connection_t *c)
  2043. {
  2044.     ngx_str_t  cert, key;

  2046.     if (ngx_http_complex_value(r, u->conf->ssl_certificate, &cert)
  2047.         != NGX_OK)
  2048.     {
  2049.         return NGX_ERROR;
  2050.     }

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

  2055.     if (*cert.data == '\0') {
  2056.         return NGX_OK;
  2057.     }

  2059.     if (ngx_http_complex_value(r, u->conf->ssl_certificate_key, &key)
  2060.         != NGX_OK)
  2061.     {
  2062.         return NGX_ERROR;
  2063.     }

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

  2068.     if (ngx_ssl_connection_certificate(c, r->pool, &cert, &key,
  2069.                                        u->conf->ssl_certificate_cache,
  2070.                                        u->conf->ssl_passwords)
  2071.         != NGX_OK)
  2072.     {
  2073.         return NGX_ERROR;
  2074.     }

  2076.     return NGX_OK;
  2077. }

  2079. #endif


  2082. static ngx_int_t
  2083. ‌ngx_http_upstream_reinit(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2084. {
  2085.     off_t         file_pos;
  2086.     ngx_chain_t  *cl;

  2088.     if (u->reinit_request(r) != NGX_OK) {
  2089.         return NGX_ERROR;
  2090.     }

  2092.     u->early_hints_length = 0;
  2093.     u->keepalive = 0;
  2094.     u->upgrade = 0;
  2095.     u->error = 0;

  2097.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2098.     u->headers_in.content_length_n = -1;
  2099.     u->headers_in.last_modified_time = -1;

  2101.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2102.                       sizeof(ngx_table_elt_t))
  2103.         != NGX_OK)
  2104.     {
  2105.         return NGX_ERROR;
  2106.     }

  2108.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2109.                       sizeof(ngx_table_elt_t))
  2110.         != NGX_OK)
  2111.     {
  2112.         return NGX_ERROR;
  2113.     }

  2115.     /* reinit the request chain */

  2117.     file_pos = 0;

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

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

  2124.         if (cl->buf->in_file) {
  2125.             cl->buf->file_pos = file_pos;
  2126.             file_pos = cl->buf->file_last;
  2127.         }
  2128.     }

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

  2132.     if (r->request_body && r->request_body->temp_file
  2133.         && r != r->main && u->output.buf)
  2134.     {
  2135.         u->output.free = ngx_alloc_chain_link(r->pool);
  2136.         if (u->output.free == NULL) {
  2137.             return NGX_ERROR;
  2138.         }

  2140.         u->output.free->buf = u->output.buf;
  2141.         u->output.free->next = NULL;

  2143.         u->output.buf->pos = u->output.buf->start;
  2144.         u->output.buf->last = u->output.buf->start;
  2145.     }

  2147.     u->output.buf = NULL;
  2148.     u->output.in = NULL;
  2149.     u->output.busy = NULL;

  2151.     /* reinit u->buffer */

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

  2155. #if (NGX_HTTP_CACHE)

  2157.     if (r->cache) {
  2158.         u->buffer.pos += r->cache->header_start;
  2159.     }

  2161. #endif

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

  2165.     return NGX_OK;
  2166. }


  2169. static void
  2170. ‌ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u,
  2171.     ngx_uint_t do_write)
  2172. {
  2173.     ngx_int_t          rc;
  2174.     ngx_connection_t  *c;

  2176.     c = u->peer.connection;

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

  2181.     if (u->state->connect_time == (ngx_msec_t) -1) {
  2182.         u->state->connect_time = ngx_current_msec - u->start_time;
  2183.     }

  2185.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2186.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2187.         return;
  2188.     }

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

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

  2194.     if (rc == NGX_ERROR) {
  2195.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2196.         return;
  2197.     }

  2199.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2200.         ngx_http_upstream_finalize_request(r, u, rc);
  2201.         return;
  2202.     }

  2204.     if (rc == NGX_AGAIN) {
  2205.         if (!c->write->ready || u->request_body_blocked) {
  2206.             ngx_add_timer(c->write, u->conf->send_timeout);

  2208.         } else if (c->write->timer_set) {
  2209.             ngx_del_timer(c->write);
  2210.         }

  2212.         if (ngx_handle_write_event(c->write, u->conf->send_lowat) != NGX_OK) {
  2213.             ngx_http_upstream_finalize_request(r, u,
  2214.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2215.             return;
  2216.         }

  2218.         if (c->write->ready && c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2219.             if (ngx_tcp_push(c->fd) == -1) {
  2220.                 ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2221.                               ngx_tcp_push_n " failed");
  2222.                 ngx_http_upstream_finalize_request(r, u,
  2223.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2224.                 return;
  2225.             }

  2227.             c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2228.         }

  2230.         if (c->read->ready) {
  2231.             ngx_post_event(c->read, &ngx_posted_events);
  2232.         }

  2234.         return;
  2235.     }

  2237.     /* rc == NGX_OK */

  2239.     if (c->write->timer_set) {
  2240.         ngx_del_timer(c->write);
  2241.     }

  2243.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2244.         if (ngx_tcp_push(c->fd) == -1) {
  2245.             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2246.                           ngx_tcp_push_n " failed");
  2247.             ngx_http_upstream_finalize_request(r, u,
  2248.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2249.             return;
  2250.         }

  2252.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2253.     }

  2255.     if (!u->conf->preserve_output) {
  2256.         u->write_event_handler = ngx_http_upstream_dummy_handler;
  2257.     }

  2259.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2260.         ngx_http_upstream_finalize_request(r, u,
  2261.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2262.         return;
  2263.     }

  2265.     if (!u->request_body_sent) {
  2266.         u->request_body_sent = 1;

  2268.         if (u->header_sent) {
  2269.             return;
  2270.         }

  2272.         if (u->conf->ignore_input) {
  2273.             ngx_http_upstream_process_header(r, u);
  2274.             return;
  2275.         }

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

  2279.         if (c->read->ready) {
  2280.             ngx_http_upstream_process_header(r, u);
  2281.             return;
  2282.         }
  2283.     }
  2284. }


  2287. static ngx_int_t
  2288. ‌ngx_http_upstream_send_request_body(ngx_http_request_t *r,
  2289.     ngx_http_upstream_t *u, ngx_uint_t do_write)
  2290. {
  2291.     ngx_int_t                  rc;
  2292.     ngx_chain_t               *out, *cl, *ln;
  2293.     ngx_connection_t          *c;
  2294.     ngx_http_core_loc_conf_t  *clcf;

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

  2299.     if (!r->request_body_no_buffering) {

  2301.         /* buffered request body */

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

  2307.         } else {
  2308.             out = NULL;
  2309.         }

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

  2313.         if (rc == NGX_AGAIN) {
  2314.             u->request_body_blocked = 1;

  2316.         } else {
  2317.             u->request_body_blocked = 0;
  2318.         }

  2320.         return rc;
  2321.     }

  2323.     if (!u->request_sent) {
  2324.         u->request_sent = 1;
  2325.         out = u->request_bufs;

  2327.         if (r->request_body->bufs) {
  2328.             for (cl = out; cl->next; cl = cl->next) { /* void */ }
  2329.             cl->next = r->request_body->bufs;
  2330.             r->request_body->bufs = NULL;
  2331.         }

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

  2336.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  2337.             return NGX_ERROR;
  2338.         }

  2340.         r->read_event_handler = ngx_http_upstream_read_request_handler;

  2342.     } else {
  2343.         out = NULL;
  2344.     }

  2346.     for ( ;; ) {

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

  2351.             if (rc == NGX_ERROR) {
  2352.                 return NGX_ERROR;
  2353.             }

  2355.             while (out) {
  2356.                 ln = out;
  2357.                 out = out->next;
  2358.                 ngx_free_chain(r->pool, ln);
  2359.             }

  2361.             if (rc == NGX_AGAIN) {
  2362.                 u->request_body_blocked = 1;

  2364.             } else {
  2365.                 u->request_body_blocked = 0;
  2366.             }

  2368.             if (rc == NGX_OK && !r->reading_body) {
  2369.                 break;
  2370.             }
  2371.         }

  2373.         if (r->reading_body) {
  2374.             /* read client request body */

  2376.             rc = ngx_http_read_unbuffered_request_body(r);

  2378.             if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2379.                 return rc;
  2380.             }

  2382.             out = r->request_body->bufs;
  2383.             r->request_body->bufs = NULL;
  2384.         }

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

  2388.         if (out == NULL) {
  2389.             rc = NGX_AGAIN;
  2390.             break;
  2391.         }

  2393.         do_write = 1;
  2394.     }

  2396.     if (!r->reading_body) {
  2397.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2398.             r->read_event_handler =
  2399.                                   ngx_http_upstream_rd_check_broken_connection;
  2400.         }
  2401.     }

  2403.     return rc;
  2404. }


  2407. static void
  2408. ‌ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  2409.     ngx_http_upstream_t *u)
  2410. {
  2411.     ngx_connection_t  *c;

  2413.     c = u->peer.connection;

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

  2418.     if (c->write->timedout) {
  2419.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2420.         return;
  2421.     }

  2423. #if (NGX_HTTP_SSL)

  2425.     if (u->ssl && c->ssl == NULL) {
  2426.         ngx_http_upstream_ssl_init_connection(r, u, c);
  2427.         return;
  2428.     }

  2430. #endif

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

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

  2437.         return;
  2438.     }

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


  2444. static void
  2445. ‌ngx_http_upstream_read_request_handler(ngx_http_request_t *r)
  2446. {
  2447.     ngx_connection_t     *c;
  2448.     ngx_http_upstream_t  *u;

  2450.     c = r->connection;
  2451.     u = r->upstream;

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

  2456.     if (c->read->timedout) {
  2457.         c->timedout = 1;
  2458.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  2459.         return;
  2460.     }

  2462.     ngx_http_upstream_send_request(r, u, 0);
  2463. }


  2466. static void
  2467. ‌ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2468. {
  2469.     ssize_t            n;
  2470.     ngx_int_t          rc;
  2471.     ngx_connection_t  *c;

  2473.     c = u->peer.connection;

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

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

  2480.     if (c->read->timedout) {
  2481.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2482.         return;
  2483.     }

  2485.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2486.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2487.         return;
  2488.     }

  2490.     if (u->buffer.start == NULL) {
  2491.         u->buffer.start = ngx_palloc(r->pool, u->conf->buffer_size);
  2492.         if (u->buffer.start == NULL) {
  2493.             ngx_http_upstream_finalize_request(r, u,
  2494.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2495.             return;
  2496.         }

  2498.         u->buffer.pos = u->buffer.start;
  2499.         u->buffer.last = u->buffer.start;
  2500.         u->buffer.end = u->buffer.start + u->conf->buffer_size;
  2501.         u->buffer.temporary = 1;

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

  2505.         if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2506.                           sizeof(ngx_table_elt_t))
  2507.             != NGX_OK)
  2508.         {
  2509.             ngx_http_upstream_finalize_request(r, u,
  2510.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2511.             return;
  2512.         }

  2514.         if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2515.                           sizeof(ngx_table_elt_t))
  2516.             != NGX_OK)
  2517.         {
  2518.             ngx_http_upstream_finalize_request(r, u,
  2519.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2520.             return;
  2521.         }

  2523. #if (NGX_HTTP_CACHE)

  2525.         if (r->cache) {
  2526.             u->buffer.pos += r->cache->header_start;
  2527.             u->buffer.last = u->buffer.pos;
  2528.         }
  2529. #endif
  2530.     }

  2532.     if (u->conf->ignore_input) {
  2533.         rc = u->process_header(r);
  2534.         goto done;
  2535.     }

  2537.     for ( ;; ) {

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

  2541.         if (n == NGX_AGAIN) {
  2542. #if 0
  2543.             ngx_add_timer(rev, u->read_timeout);
  2544. #endif

  2546.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2547.                 ngx_http_upstream_finalize_request(r, u,
  2548.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2549.                 return;
  2550.             }

  2552.             return;
  2553.         }

  2555.         if (n == 0) {
  2556.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2557.                           "upstream prematurely closed connection");
  2558.         }

  2560.         if (n == NGX_ERROR || n == 0) {
  2561.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2562.             return;
  2563.         }

  2565. #if (NGX_HTTP_SSL)
  2566.         if (u->ssl && c->ssl == NULL) {
  2567.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2568.                           "upstream prematurely sent response");
  2569.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2570.             return;
  2571.         }
  2572. #endif

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

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

  2578. #if 0
  2579.         u->valid_header_in = 0;

  2581.         u->peer.cached = 0;
  2582. #endif

  2584.         u->response_received = 1;

  2586. again:

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

  2590.         if (rc == NGX_AGAIN) {

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

  2596.                 ngx_http_upstream_next(r, u,
  2597.                                        NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2598.                 return;
  2599.             }

  2601.             continue;
  2602.         }

  2604.         if (rc == NGX_HTTP_UPSTREAM_EARLY_HINTS) {
  2605.             rc = ngx_http_upstream_process_early_hints(r, u);

  2607.             if (rc == NGX_OK) {
  2608.                 goto again;
  2609.             }
  2610.         }

  2612.         break;
  2613.     }

  2615. done:

  2617.     if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2618.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2619.         return;
  2620.     }

  2622.     if (rc == NGX_ERROR) {
  2623.         ngx_http_upstream_finalize_request(r, u,
  2624.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2625.         return;
  2626.     }

  2628.     /* rc == NGX_OK */

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

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

  2634.         if (ngx_http_upstream_test_next(r, u) == NGX_OK) {
  2635.             return;
  2636.         }

  2638.         if (ngx_http_upstream_intercept_errors(r, u) == NGX_OK) {
  2639.             return;
  2640.         }
  2641.     }

  2643.     if (u->peer.notify) {
  2644.         u->peer.notify(&u->peer, u->peer.data, NGX_HTTP_UPSTREAM_NOTIFY_HEADER);
  2645.     }

  2647.     rc = ngx_http_upstream_process_headers(r, u);

  2649.     if (rc == NGX_DONE) {
  2650.         return;
  2651.     }

  2653.     if (rc == NGX_ERROR) {
  2654.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  2655.         return;
  2656.     }

  2658.     ngx_http_upstream_send_response(r, u);
  2659. }


  2662. static ngx_int_t
  2663. ‌ngx_http_upstream_process_early_hints(ngx_http_request_t *r,
  2664.     ngx_http_upstream_t *u)
  2665. {
  2666.     u_char            *p;
  2667.     ngx_uint_t         i;
  2668.     ngx_list_part_t   *part;
  2669.     ngx_table_elt_t   *h, *ho;
  2670.     ngx_connection_t  *c;

  2672.     c = r->connection;

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

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

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

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

  2682.             part = &u->headers_in.headers.part;
  2683.             h = part->elts;

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

  2687.                 if (i >= part->nelts) {
  2688.                     if (part->next == NULL) {
  2689.                         break;
  2690.                     }

  2692.                     part = part->next;
  2693.                     h = part->elts;
  2694.                     i = 0;
  2695.                 }

  2697.                 if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  2698.                                   h[i].lowcase_key, h[i].key.len))
  2699.                 {
  2700.                     continue;
  2701.                 }

  2703.                 ho = ngx_list_push(&r->headers_out.headers);
  2704.                 if (ho == NULL) {
  2705.                     return NGX_ERROR;
  2706.                 }

  2708.                 *ho = h[i];
  2709.             }

  2711.             if (ngx_http_send_early_hints(r) == NGX_ERROR) {
  2712.                 return NGX_ERROR;
  2713.             }

  2715.             if (c->buffered) {
  2716.                 if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2717.                     return NGX_ERROR;
  2718.                 }

  2720.                 r->write_event_handler = ngx_http_upstream_early_hints_writer;
  2721.             }

  2723.         } else {
  2724.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2725.                           "upstream sent too big early hints");
  2726.         }
  2727.     }

  2729.     ngx_http_clean_header(r);

  2731.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2732.     u->headers_in.content_length_n = -1;
  2733.     u->headers_in.last_modified_time = -1;

  2735.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2736.                       sizeof(ngx_table_elt_t))
  2737.         != NGX_OK)
  2738.     {
  2739.         return NGX_ERROR;
  2740.     }

  2742.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2743.                       sizeof(ngx_table_elt_t))
  2744.         != NGX_OK)
  2745.     {
  2746.         return NGX_ERROR;
  2747.     }

  2749.     p = u->buffer.pos;

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

  2753. #if (NGX_HTTP_CACHE)

  2755.     if (r->cache) {
  2756.         u->buffer.pos += r->cache->header_start;
  2757.     }

  2759. #endif

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

  2763.     return NGX_OK;
  2764. }


  2767. static void
  2768. ‌ngx_http_upstream_early_hints_writer(ngx_http_request_t *r)
  2769. {
  2770.     ngx_connection_t     *c;
  2771.     ngx_http_upstream_t  *u;

  2773.     c = r->connection;
  2774.     u = r->upstream;

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

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

  2781.     if (ngx_http_write_filter(r, NULL) == NGX_ERROR) {
  2782.         ngx_http_upstream_finalize_request(r, u,
  2783.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2784.         return;
  2785.     }

  2787.     if (!c->buffered) {
  2788.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2789.             r->write_event_handler =
  2790.                                   ngx_http_upstream_wr_check_broken_connection;

  2792.         } else {
  2793.             r->write_event_handler = ngx_http_request_empty_handler;
  2794.         }
  2795.     }

  2797.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2798.         ngx_http_upstream_finalize_request(r, u,
  2799.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2800.     }
  2801. }


  2804. static ngx_int_t
  2805. ‌ngx_http_upstream_test_next(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2806. {
  2807.     ngx_msec_t                 timeout;
  2808.     ngx_uint_t                 status, mask;
  2809.     ngx_http_upstream_next_t  *un;

  2811.     status = u->headers_in.status_n;

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

  2815.         if (status != un->status) {
  2816.             continue;
  2817.         }

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

  2821.         if (u->request_sent
  2822.             && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  2823.         {
  2824.             mask = un->mask | NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;

  2826.         } else {
  2827.             mask = un->mask;
  2828.         }

  2830.         if (u->peer.tries > 1
  2831.             && ((u->conf->next_upstream & mask) == mask)
  2832.             && !(u->request_sent && r->request_body_no_buffering)
  2833.             && !(timeout && ngx_current_msec - u->peer.start_time >= timeout))
  2834.         {
  2835.             ngx_http_upstream_next(r, u, un->mask);
  2836.             return NGX_OK;
  2837.         }

  2839. #if (NGX_HTTP_CACHE)

  2841.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2842.             && (u->conf->cache_use_stale & un->mask))
  2843.         {
  2844.             ngx_int_t  rc;

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

  2848.             if (rc != NGX_OK) {
  2849.                 ngx_http_upstream_finalize_request(r, u, rc);
  2850.                 return NGX_OK;
  2851.             }

  2853.             u->cache_status = NGX_HTTP_CACHE_STALE;
  2854.             rc = ngx_http_upstream_cache_send(r, u);

  2856.             if (rc == NGX_DONE) {
  2857.                 return NGX_OK;
  2858.             }

  2860.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2861.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2862.             }

  2864.             ngx_http_upstream_finalize_request(r, u, rc);
  2865.             return NGX_OK;
  2866.         }

  2868. #endif

  2870.         break;
  2871.     }

  2873. #if (NGX_HTTP_CACHE)

  2875.     if (status == NGX_HTTP_NOT_MODIFIED
  2876.         && u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2877.         && u->conf->cache_revalidate)
  2878.     {
  2879.         time_t     now, valid, updating, error;
  2880.         ngx_int_t  rc;

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

  2885.         now = ngx_time();

  2887.         valid = r->cache->valid_sec;
  2888.         updating = r->cache->updating_sec;
  2889.         error = r->cache->error_sec;

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

  2893.         if (rc != NGX_OK) {
  2894.             ngx_http_upstream_finalize_request(r, u, rc);
  2895.             return NGX_OK;
  2896.         }

  2898.         u->cache_status = NGX_HTTP_CACHE_REVALIDATED;
  2899.         rc = ngx_http_upstream_cache_send(r, u);

  2901.         if (rc == NGX_DONE) {
  2902.             return NGX_OK;
  2903.         }

  2905.         if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2906.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2907.         }

  2909.         if (valid == 0) {
  2910.             valid = r->cache->valid_sec;
  2911.             updating = r->cache->updating_sec;
  2912.             error = r->cache->error_sec;
  2913.         }

  2915.         if (valid == 0) {
  2916.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2917.                                               u->headers_in.status_n);
  2918.             if (valid) {
  2919.                 valid = now + valid;
  2920.             }
  2921.         }

  2923.         if (valid) {
  2924.             r->cache->valid_sec = valid;
  2925.             r->cache->updating_sec = updating;
  2926.             r->cache->error_sec = error;

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

  2930.             ngx_http_file_cache_update_header(r);
  2931.         }

  2933.         ngx_http_upstream_finalize_request(r, u, rc);
  2934.         return NGX_OK;
  2935.     }

  2937. #endif

  2939.     return NGX_DECLINED;
  2940. }


  2943. static ngx_int_t
  2944. ‌ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  2945.     ngx_http_upstream_t *u)
  2946. {
  2947.     ngx_int_t                  status;
  2948.     ngx_uint_t                 i;
  2949.     ngx_table_elt_t           *h, *ho, **ph;
  2950.     ngx_http_err_page_t       *err_page;
  2951.     ngx_http_core_loc_conf_t  *clcf;

  2953.     status = u->headers_in.status_n;

  2955.     if (status == NGX_HTTP_NOT_FOUND && u->conf->intercept_404) {
  2956.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_NOT_FOUND);
  2957.         return NGX_OK;
  2958.     }

  2960.     if (!u->conf->intercept_errors) {
  2961.         return NGX_DECLINED;
  2962.     }

  2964.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2966.     if (clcf->error_pages == NULL) {
  2967.         return NGX_DECLINED;
  2968.     }

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

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

  2975.             if (status == NGX_HTTP_UNAUTHORIZED
  2976.                 && u->headers_in.www_authenticate)
  2977.             {
  2978.                 h = u->headers_in.www_authenticate;
  2979.                 ph = &r->headers_out.www_authenticate;

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

  2984.                     if (ho == NULL) {
  2985.                         ngx_http_upstream_finalize_request(r, u,
  2986.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2987.                         return NGX_OK;
  2988.                     }

  2990.                     *ho = *h;
  2991.                     ho->next = NULL;

  2993.                     *ph = ho;
  2994.                     ph = &ho->next;

  2996.                     h = h->next;
  2997.                 }
  2998.             }

  3000. #if (NGX_HTTP_CACHE)

  3002.             if (r->cache) {

  3004.                 if (u->headers_in.no_cache || u->headers_in.expired) {
  3005.                     u->cacheable = 0;
  3006.                 }

  3008.                 if (u->cacheable) {
  3009.                     time_t  valid;

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

  3013.                     if (valid == 0) {
  3014.                         valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  3015.                                                           status);
  3016.                         if (valid) {
  3017.                             r->cache->valid_sec = ngx_time() + valid;
  3018.                         }
  3019.                     }

  3021.                     if (valid) {
  3022.                         r->cache->error = status;
  3023.                     }
  3024.                 }

  3026.                 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3027.             }
  3028. #endif
  3029.             ngx_http_upstream_finalize_request(r, u, status);

  3031.             return NGX_OK;
  3032.         }
  3033.     }

  3035.     return NGX_DECLINED;
  3036. }


  3039. static ngx_int_t
  3040. ‌ngx_http_upstream_test_connect(ngx_connection_t *c)
  3041. {
  3042.     int        err;
  3043.     socklen_t  len;

  3045. #if (NGX_HAVE_KQUEUE)

  3047.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
  3048.         if (c->write->pending_eof || c->read->pending_eof) {
  3049.             if (c->write->pending_eof) {
  3050.                 err = c->write->kq_errno;

  3052.             } else {
  3053.                 err = c->read->kq_errno;
  3054.             }

  3056.             c->log->action = "connecting to upstream";
  3057.             (void) ngx_connection_error(c, err,
  3058.                                     "kevent() reported that connect() failed");
  3059.             return NGX_ERROR;
  3060.         }

  3062.     } else
  3063. #endif
  3064.     {
  3065.         err = 0;
  3066.         len = sizeof(int);

  3068.         /*
  3069.          * BSDs and Linux return 0 and set a pending error in err
  3070.          * Solaris returns -1 and sets errno
  3071.          */

  3073.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3074.             == -1)
  3075.         {
  3076.             err = ngx_socket_errno;
  3077.         }

  3079.         if (err) {
  3080.             c->log->action = "connecting to upstream";
  3081.             (void) ngx_connection_error(c, err, "connect() failed");
  3082.             return NGX_ERROR;
  3083.         }
  3084.     }

  3086.     return NGX_OK;
  3087. }


  3090. static ngx_int_t
  3091. ‌ngx_http_upstream_process_headers(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3092. {
  3093.     ngx_str_t                       uri, args;
  3094.     ngx_uint_t                      i, flags;
  3095.     ngx_list_part_t                *part;
  3096.     ngx_table_elt_t                *h;
  3097.     ngx_http_upstream_header_t     *hh;
  3098.     ngx_http_upstream_main_conf_t  *umcf;

  3100.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  3102.     if (u->headers_in.no_cache || u->headers_in.expired) {
  3103.         u->cacheable = 0;
  3104.     }

  3106.     if (u->headers_in.x_accel_redirect
  3107.         && !(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT))
  3108.     {
  3109.         if (u->cleanup) {
  3110.             ngx_http_upstream_finalize_request(r, u, NGX_DECLINED);
  3111.         }

  3113.         part = &u->headers_in.headers.part;
  3114.         h = part->elts;

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

  3118.             if (i >= part->nelts) {
  3119.                 if (part->next == NULL) {
  3120.                     break;
  3121.                 }

  3123.                 part = part->next;
  3124.                 h = part->elts;
  3125.                 i = 0;
  3126.             }

  3128.             if (h[i].hash == 0) {
  3129.                 continue;
  3130.             }

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

  3135.             if (hh && hh->redirect) {
  3136.                 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  3137.                     ngx_http_finalize_request(r,
  3138.                                               NGX_HTTP_INTERNAL_SERVER_ERROR);
  3139.                     return NGX_DONE;
  3140.                 }
  3141.             }
  3142.         }

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

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

  3149.         } else {
  3150.             ngx_str_null(&args);
  3151.             flags = NGX_HTTP_LOG_UNSAFE;

  3153.             if (ngx_http_parse_unsafe_uri(r, &uri, &args, &flags) != NGX_OK) {
  3154.                 ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  3155.                 return NGX_DONE;
  3156.             }

  3158.             if (r->method != NGX_HTTP_HEAD) {
  3159.                 r->method = NGX_HTTP_GET;
  3160.                 r->method_name = ngx_http_core_get_method;
  3161.             }

  3163.             ngx_http_internal_redirect(r, &uri, &args);
  3164.         }

  3166.         ngx_http_finalize_request(r, NGX_DONE);
  3167.         return NGX_DONE;
  3168.     }

  3170.     part = &u->headers_in.headers.part;
  3171.     h = part->elts;

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

  3175.         if (i >= part->nelts) {
  3176.             if (part->next == NULL) {
  3177.                 break;
  3178.             }

  3180.             part = part->next;
  3181.             h = part->elts;
  3182.             i = 0;
  3183.         }

  3185.         if (h[i].hash == 0) {
  3186.             continue;
  3187.         }

  3189.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3190.                           h[i].lowcase_key, h[i].key.len))
  3191.         {
  3192.             continue;
  3193.         }

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

  3198.         if (hh) {
  3199.             if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  3200.                 return NGX_ERROR;
  3201.             }

  3203.             continue;
  3204.         }

  3206.         if (ngx_http_upstream_copy_header_line(r, &h[i], 0) != NGX_OK) {
  3207.             return NGX_ERROR;
  3208.         }
  3209.     }

  3211.     if (r->headers_out.server && r->headers_out.server->value.data == NULL) {
  3212.         r->headers_out.server->hash = 0;
  3213.     }

  3215.     if (r->headers_out.date && r->headers_out.date->value.data == NULL) {
  3216.         r->headers_out.date->hash = 0;
  3217.     }

  3219.     r->headers_out.status = u->headers_in.status_n;
  3220.     r->headers_out.status_line = u->headers_in.status_line;

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

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

  3226.     if (u->conf->force_ranges) {
  3227.         r->allow_ranges = 1;
  3228.         r->single_range = 1;

  3230. #if (NGX_HTTP_CACHE)
  3231.         if (r->cached) {
  3232.             r->single_range = 0;
  3233.         }
  3234. #endif
  3235.     }

  3237.     u->length = -1;

  3239.     return NGX_OK;
  3240. }


  3243. static ngx_int_t
  3244. ‌ngx_http_upstream_process_trailers(ngx_http_request_t *r,
  3245.     ngx_http_upstream_t *u)
  3246. {
  3247.     ngx_uint_t        i;
  3248.     ngx_list_part_t  *part;
  3249.     ngx_table_elt_t  *h, *ho;

  3251.     if (!u->conf->pass_trailers) {
  3252.         return NGX_OK;
  3253.     }

  3255.     part = &u->headers_in.trailers.part;
  3256.     h = part->elts;

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

  3260.         if (i >= part->nelts) {
  3261.             if (part->next == NULL) {
  3262.                 break;
  3263.             }

  3265.             part = part->next;
  3266.             h = part->elts;
  3267.             i = 0;
  3268.         }

  3270.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3271.                           h[i].lowcase_key, h[i].key.len))
  3272.         {
  3273.             continue;
  3274.         }

  3276.         ho = ngx_list_push(&r->headers_out.trailers);
  3277.         if (ho == NULL) {
  3278.             return NGX_ERROR;
  3279.         }

  3281.         *ho = h[i];
  3282.     }

  3284.     return NGX_OK;
  3285. }


  3288. static void
  3289. ‌ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3290. {
  3291.     ssize_t                    n;
  3292.     ngx_int_t                  rc;
  3293.     ngx_event_pipe_t          *p;
  3294.     ngx_connection_t          *c;
  3295.     ngx_http_core_loc_conf_t  *clcf;

  3297.     rc = ngx_http_send_header(r);

  3299.     if (rc == NGX_ERROR || rc > NGX_OK || r->post_action) {
  3300.         ngx_http_upstream_finalize_request(r, u, rc);
  3301.         return;
  3302.     }

  3304.     u->header_sent = 1;

  3306.     if (u->upgrade) {

  3308. #if (NGX_HTTP_CACHE)

  3310.         if (r->cache) {
  3311.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3312.         }

  3314. #endif

  3316.         ngx_http_upstream_upgrade(r, u);
  3317.         return;
  3318.     }

  3320.     c = r->connection;

  3322.     if (r->header_only) {

  3324.         if (!u->buffering) {
  3325.             ngx_http_upstream_finalize_request(r, u, rc);
  3326.             return;
  3327.         }

  3329.         if (!u->cacheable && !u->store) {
  3330.             ngx_http_upstream_finalize_request(r, u, rc);
  3331.             return;
  3332.         }

  3334.         u->pipe->downstream_error = 1;
  3335.     }

  3337.     if (r->request_body && r->request_body->temp_file
  3338.         && r == r->main && !r->preserve_body
  3339.         && !u->conf->preserve_output)
  3340.     {
  3341.         ngx_pool_run_cleanup_file(r->pool, r->request_body->temp_file->file.fd);
  3342.         r->request_body->temp_file->file.fd = NGX_INVALID_FILE;
  3343.     }

  3345.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3347.     if (!u->buffering) {

  3349. #if (NGX_HTTP_CACHE)

  3351.         if (r->cache) {
  3352.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3353.         }

  3355. #endif

  3357.         if (u->input_filter == NULL) {
  3358.             u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
  3359.             u->input_filter = ngx_http_upstream_non_buffered_filter;
  3360.             u->input_filter_ctx = r;
  3361.         }

  3363.         u->read_event_handler = ngx_http_upstream_process_non_buffered_upstream;
  3364.         r->write_event_handler =
  3365.                              ngx_http_upstream_process_non_buffered_downstream;

  3367.         r->limit_rate = 0;
  3368.         r->limit_rate_set = 1;

  3370.         if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
  3371.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3372.             return;
  3373.         }

  3375.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3376.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3377.             return;
  3378.         }

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

  3382.         if (n) {
  3383.             u->buffer.last = u->buffer.pos;

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

  3387.             if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  3388.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3389.                 return;
  3390.             }

  3392.             ngx_http_upstream_process_non_buffered_downstream(r);

  3394.         } else {
  3395.             u->buffer.pos = u->buffer.start;
  3396.             u->buffer.last = u->buffer.start;

  3398.             if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3399.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3400.                 return;
  3401.             }

  3403.             ngx_http_upstream_process_non_buffered_upstream(r, u);
  3404.         }

  3406.         return;
  3407.     }

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

  3411. #if (NGX_HTTP_CACHE)

  3413.     if (r->cache && r->cache->file.fd != NGX_INVALID_FILE) {
  3414.         ngx_pool_run_cleanup_file(r->pool, r->cache->file.fd);
  3415.         r->cache->file.fd = NGX_INVALID_FILE;
  3416.     }

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

  3420.     case NGX_ERROR:
  3421.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3422.         return;

  3424.     case NGX_DECLINED:
  3425.         u->cacheable = 0;
  3426.         break;

  3428.     default: /* NGX_OK */

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

  3432.             /* create cache if previously bypassed */

  3434.             if (ngx_http_file_cache_create(r) != NGX_OK) {
  3435.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3436.                 return;
  3437.             }
  3438.         }

  3440.         break;
  3441.     }

  3443.     if (u->cacheable) {
  3444.         time_t  now, valid;

  3446.         now = ngx_time();

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

  3450.         if (valid == 0) {
  3451.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  3452.                                               u->headers_in.status_n);
  3453.             if (valid) {
  3454.                 r->cache->valid_sec = now + valid;
  3455.             }
  3456.         }

  3458.         if (valid) {
  3459.             r->cache->date = now;
  3460.             r->cache->body_start = (u_short) (u->buffer.pos - u->buffer.start);

  3462.             if (u->headers_in.status_n == NGX_HTTP_OK
  3463.                 || u->headers_in.status_n == NGX_HTTP_PARTIAL_CONTENT)
  3464.             {
  3465.                 r->cache->last_modified = u->headers_in.last_modified_time;

  3467.                 if (u->headers_in.etag) {
  3468.                     r->cache->etag = u->headers_in.etag->value;

  3470.                 } else {
  3471.                     ngx_str_null(&r->cache->etag);
  3472.                 }

  3474.             } else {
  3475.                 r->cache->last_modified = -1;
  3476.                 ngx_str_null(&r->cache->etag);
  3477.             }

  3479.             if (ngx_http_file_cache_set_header(r, u->buffer.start) != NGX_OK) {
  3480.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3481.                 return;
  3482.             }

  3484.         } else {
  3485.             u->cacheable = 0;
  3486.         }
  3487.     }

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

  3492.     if (u->cacheable == 0 && r->cache) {
  3493.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3494.     }

  3496.     if (r->header_only && !u->cacheable && !u->store) {
  3497.         ngx_http_upstream_finalize_request(r, u, 0);
  3498.         return;
  3499.     }

  3501. #endif

  3503.     p = u->pipe;

  3505.     p->output_filter = ngx_http_upstream_output_filter;
  3506.     p->output_ctx = r;
  3507.     p->tag = u->output.tag;
  3508.     p->bufs = u->conf->bufs;
  3509.     p->busy_size = u->conf->busy_buffers_size;
  3510.     p->upstream = u->peer.connection;
  3511.     p->downstream = c;
  3512.     p->pool = r->pool;
  3513.     p->log = c->log;
  3514.     p->limit_rate = ngx_http_complex_value_size(r, u->conf->limit_rate, 0);
  3515.     p->start_sec = ngx_time();

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

  3519.     p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  3520.     if (p->temp_file == NULL) {
  3521.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3522.         return;
  3523.     }

  3525.     p->temp_file->file.fd = NGX_INVALID_FILE;
  3526.     p->temp_file->file.log = c->log;
  3527.     p->temp_file->path = u->conf->temp_path;
  3528.     p->temp_file->pool = r->pool;

  3530.     if (p->cacheable) {
  3531.         p->temp_file->persistent = 1;

  3533. #if (NGX_HTTP_CACHE)
  3534.         if (r->cache && !r->cache->file_cache->use_temp_path) {
  3535.             p->temp_file->path = r->cache->file_cache->path;
  3536.             p->temp_file->file.name = r->cache->file.name;
  3537.         }
  3538. #endif

  3540.     } else {
  3541.         p->temp_file->log_level = NGX_LOG_WARN;
  3542.         p->temp_file->warn = "an upstream response is buffered "
  3543.                              "to a temporary file";
  3544.     }

  3546.     p->max_temp_file_size = u->conf->max_temp_file_size;
  3547.     p->temp_file_write_size = u->conf->temp_file_write_size;

  3549. #if (NGX_THREADS)
  3550.     if (clcf->aio == NGX_HTTP_AIO_THREADS && clcf->aio_write) {
  3551.         p->thread_handler = ngx_http_upstream_thread_handler;
  3552.         p->thread_ctx = r;
  3553.     }
  3554. #endif

  3556.     p->preread_bufs = ngx_alloc_chain_link(r->pool);
  3557.     if (p->preread_bufs == NULL) {
  3558.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3559.         return;
  3560.     }

  3562.     p->preread_bufs->buf = &u->buffer;
  3563.     p->preread_bufs->next = NULL;
  3564.     u->buffer.recycled = 1;

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

  3568.     if (u->cacheable) {

  3570.         p->buf_to_file = ngx_calloc_buf(r->pool);
  3571.         if (p->buf_to_file == NULL) {
  3572.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3573.             return;
  3574.         }

  3576.         p->buf_to_file->start = u->buffer.start;
  3577.         p->buf_to_file->pos = u->buffer.start;
  3578.         p->buf_to_file->last = u->buffer.pos;
  3579.         p->buf_to_file->temporary = 1;
  3580.     }

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

  3585.     /*
  3586.      * event_pipe would do u->buffer.last += p->preread_size
  3587.      * as though these bytes were read
  3588.      */
  3589.     u->buffer.last = u->buffer.pos;

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

  3593.         /*
  3594.          * we need to disable the use of sendfile() if we use cyclic temp file
  3595.          * because the writing a new data may interfere with sendfile()
  3596.          * that uses the same kernel file pages (at least on FreeBSD)
  3597.          */

  3599.         p->cyclic_temp_file = 1;
  3600.         c->sendfile = 0;

  3602.     } else {
  3603.         p->cyclic_temp_file = 0;
  3604.     }

  3606.     p->read_timeout = u->conf->read_timeout;
  3607.     p->send_timeout = clcf->send_timeout;
  3608.     p->send_lowat = clcf->send_lowat;

  3610.     p->length = -1;

  3612.     if (u->input_filter_init
  3613.         && u->input_filter_init(p->input_ctx) != NGX_OK)
  3614.     {
  3615.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3616.         return;
  3617.     }

  3619.     u->read_event_handler = ngx_http_upstream_process_upstream;
  3620.     r->write_event_handler = ngx_http_upstream_process_downstream;

  3622.     ngx_http_upstream_process_upstream(r, u);
  3623. }


  3626. static void
  3627. ‌ngx_http_upstream_upgrade(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3628. {
  3629.     ngx_connection_t          *c;
  3630.     ngx_http_core_loc_conf_t  *clcf;

  3632.     c = r->connection;
  3633.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  3637.     if (r != r->main) {
  3638.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  3639.                       "connection upgrade in subrequest");
  3640.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3641.         return;
  3642.     }

  3644.     r->keepalive = 0;
  3645.     c->log->action = "proxying upgraded connection";

  3647.     u->read_event_handler = ngx_http_upstream_upgraded_read_upstream;
  3648.     u->write_event_handler = ngx_http_upstream_upgraded_write_upstream;
  3649.     r->read_event_handler = ngx_http_upstream_upgraded_read_downstream;
  3650.     r->write_event_handler = ngx_http_upstream_upgraded_write_downstream;

  3652.     if (clcf->tcp_nodelay) {

  3654.         if (ngx_tcp_nodelay(c) != NGX_OK) {
  3655.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3656.             return;
  3657.         }

  3659.         if (ngx_tcp_nodelay(u->peer.connection) != NGX_OK) {
  3660.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3661.             return;
  3662.         }
  3663.     }

  3665.     if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3666.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3667.         return;
  3668.     }

  3670.     if (u->peer.connection->read->ready
  3671.         || u->buffer.pos != u->buffer.last)
  3672.     {
  3673.         ngx_post_event(c->read, &ngx_posted_events);
  3674.         ngx_http_upstream_process_upgraded(r, 1, 1);
  3675.         return;
  3676.     }

  3678.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3679. }


  3682. static void
  3683. ‌ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r)
  3684. {
  3685.     ngx_http_upstream_process_upgraded(r, 0, 0);
  3686. }


  3689. static void
  3690. ‌ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r)
  3691. {
  3692.     ngx_http_upstream_process_upgraded(r, 1, 1);
  3693. }


  3696. static void
  3697. ‌ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  3698.     ngx_http_upstream_t *u)
  3699. {
  3700.     ngx_http_upstream_process_upgraded(r, 1, 0);
  3701. }


  3704. static void
  3705. ‌ngx_http_upstream_upgraded_write_upstream(ngx_http_request_t *r,
  3706.     ngx_http_upstream_t *u)
  3707. {
  3708.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3709. }


  3712. static void
  3713. ‌ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  3714.     ngx_uint_t from_upstream, ngx_uint_t do_write)
  3715. {
  3716.     size_t                     size;
  3717.     ssize_t                    n;
  3718.     ngx_buf_t                 *b;
  3719.     ngx_uint_t                 flags;
  3720.     ngx_connection_t          *c, *downstream, *upstream, *dst, *src;
  3721.     ngx_http_upstream_t       *u;
  3722.     ngx_http_core_loc_conf_t  *clcf;

  3724.     c = r->connection;
  3725.     u = r->upstream;

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

  3730.     downstream = c;
  3731.     upstream = u->peer.connection;

  3733.     if (downstream->write->timedout) {
  3734.         c->timedout = 1;
  3735.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3736.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3737.         return;
  3738.     }

  3740.     if (upstream->read->timedout || upstream->write->timedout) {
  3741.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3742.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3743.         return;
  3744.     }

  3746.     if (from_upstream) {
  3747.         src = upstream;
  3748.         dst = downstream;
  3749.         b = &u->buffer;

  3751.     } else {
  3752.         src = downstream;
  3753.         dst = upstream;
  3754.         b = &u->from_client;

  3756.         if (r->header_in->last > r->header_in->pos) {
  3757.             b = r->header_in;
  3758.             b->end = b->last;
  3759.             do_write = 1;
  3760.         }

  3762.         if (b->start == NULL) {
  3763.             b->start = ngx_palloc(r->pool, u->conf->buffer_size);
  3764.             if (b->start == NULL) {
  3765.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3766.                 return;
  3767.             }

  3769.             b->pos = b->start;
  3770.             b->last = b->start;
  3771.             b->end = b->start + u->conf->buffer_size;
  3772.             b->temporary = 1;
  3773.             b->tag = u->output.tag;
  3774.         }
  3775.     }

  3777.     for ( ;; ) {

  3779.         if (do_write) {

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

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

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

  3787.                 if (n == NGX_ERROR) {
  3788.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3789.                     return;
  3790.                 }

  3792.                 if (n > 0) {
  3793.                     b->pos += n;

  3795.                     if (b->pos == b->last) {
  3796.                         b->pos = b->start;
  3797.                         b->last = b->start;
  3798.                     }
  3799.                 }
  3800.             }
  3801.         }

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

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

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

  3809.             if (n == NGX_AGAIN || n == 0) {
  3810.                 break;
  3811.             }

  3813.             if (n > 0) {
  3814.                 do_write = 1;
  3815.                 b->last += n;

  3817.                 if (from_upstream) {
  3818.                     u->state->bytes_received += n;
  3819.                 }

  3821.                 continue;
  3822.             }

  3824.             if (n == NGX_ERROR) {
  3825.                 src->read->eof = 1;
  3826.             }
  3827.         }

  3829.         break;
  3830.     }

  3832.     if ((upstream->read->eof && u->buffer.pos == u->buffer.last)
  3833.         || (downstream->read->eof && u->from_client.pos == u->from_client.last)
  3834.         || (downstream->read->eof && upstream->read->eof))
  3835.     {
  3836.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3837.                        "http upstream upgraded done");
  3838.         ngx_http_upstream_finalize_request(r, u, 0);
  3839.         return;
  3840.     }

  3842.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3844.     if (ngx_handle_write_event(upstream->write, u->conf->send_lowat)
  3845.         != NGX_OK)
  3846.     {
  3847.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3848.         return;
  3849.     }

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

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

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

  3861.     } else {
  3862.         flags = 0;
  3863.     }

  3865.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  3866.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3867.         return;
  3868.     }

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

  3873.     } else if (upstream->read->timer_set) {
  3874.         ngx_del_timer(upstream->read);
  3875.     }

  3877.     if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3878.         != NGX_OK)
  3879.     {
  3880.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3881.         return;
  3882.     }

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

  3887.     } else {
  3888.         flags = 0;
  3889.     }

  3891.     if (ngx_handle_read_event(downstream->read, flags) != NGX_OK) {
  3892.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3893.         return;
  3894.     }

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

  3899.     } else if (downstream->write->timer_set) {
  3900.         ngx_del_timer(downstream->write);
  3901.     }
  3902. }


  3905. static void
  3906. ‌ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r)
  3907. {
  3908.     ngx_event_t          *wev;
  3909.     ngx_connection_t     *c;
  3910.     ngx_http_upstream_t  *u;

  3912.     c = r->connection;
  3913.     u = r->upstream;
  3914.     wev = c->write;

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

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

  3921.     if (wev->timedout) {
  3922.         c->timedout = 1;
  3923.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3924.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3925.         return;
  3926.     }

  3928.     ngx_http_upstream_process_non_buffered_request(r, 1);
  3929. }


  3932. static void
  3933. ‌ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  3934.     ngx_http_upstream_t *u)
  3935. {
  3936.     ngx_connection_t  *c;

  3938.     c = u->peer.connection;

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

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

  3945.     if (c->read->timedout) {
  3946.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3947.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3948.         return;
  3949.     }

  3951.     ngx_http_upstream_process_non_buffered_request(r, 0);
  3952. }


  3955. static void
  3956. ‌ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  3957.     ngx_uint_t do_write)
  3958. {
  3959.     size_t                     size;
  3960.     ssize_t                    n;
  3961.     ngx_buf_t                 *b;
  3962.     ngx_int_t                  rc;
  3963.     ngx_uint_t                 flags;
  3964.     ngx_connection_t          *downstream, *upstream;
  3965.     ngx_http_upstream_t       *u;
  3966.     ngx_http_core_loc_conf_t  *clcf;

  3968.     u = r->upstream;
  3969.     downstream = r->connection;
  3970.     upstream = u->peer.connection;

  3972.     b = &u->buffer;

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

  3976.     for ( ;; ) {

  3978.         if (do_write) {

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

  3983.                 if (rc == NGX_ERROR) {
  3984.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3985.                     return;
  3986.                 }

  3988.                 ngx_chain_update_chains(r->pool, &u->free_bufs, &u->busy_bufs,
  3989.                                         &u->out_bufs, u->output.tag);
  3990.             }

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

  3994.                 if (u->length == 0
  3995.                     || (upstream->read->eof && u->length == -1))
  3996.                 {
  3997.                     ngx_http_upstream_finalize_request(r, u, 0);
  3998.                     return;
  3999.                 }

  4001.                 if (upstream->read->eof) {
  4002.                     ngx_log_error(NGX_LOG_ERR, upstream->log, 0,
  4003.                                   "upstream prematurely closed connection");

  4005.                     ngx_http_upstream_finalize_request(r, u,
  4006.                                                        NGX_HTTP_BAD_GATEWAY);
  4007.                     return;
  4008.                 }

  4010.                 if (upstream->read->error || u->error) {
  4011.                     ngx_http_upstream_finalize_request(r, u,
  4012.                                                        NGX_HTTP_BAD_GATEWAY);
  4013.                     return;
  4014.                 }

  4016.                 b->pos = b->start;
  4017.                 b->last = b->start;
  4018.             }
  4019.         }

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

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

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

  4027.             if (n == NGX_AGAIN) {
  4028.                 break;
  4029.             }

  4031.             if (n > 0) {
  4032.                 u->state->bytes_received += n;
  4033.                 u->state->response_length += n;

  4035.                 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  4036.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4037.                     return;
  4038.                 }
  4039.             }

  4041.             do_write = 1;

  4043.             continue;
  4044.         }

  4046.         break;
  4047.     }

  4049.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4051.     if (downstream->data == r) {
  4052.         if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  4053.             != NGX_OK)
  4054.         {
  4055.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4056.             return;
  4057.         }
  4058.     }

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

  4063.     } else if (downstream->write->timer_set) {
  4064.         ngx_del_timer(downstream->write);
  4065.     }

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

  4070.     } else {
  4071.         flags = 0;
  4072.     }

  4074.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  4075.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4076.         return;
  4077.     }

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

  4082.     } else if (upstream->read->timer_set) {
  4083.         ngx_del_timer(upstream->read);
  4084.     }
  4085. }


  4088. ngx_int_t
  4089. ‌ngx_http_upstream_non_buffered_filter_init(void *data)
  4090. {
  4091.     return NGX_OK;
  4092. }


  4095. ngx_int_t
  4096. ‌ngx_http_upstream_non_buffered_filter(void *data, ssize_t bytes)
  4097. {
  4098.     ngx_http_request_t  *r = data;

  4100.     ngx_buf_t            *b;
  4101.     ngx_chain_t          *cl, **ll;
  4102.     ngx_http_upstream_t  *u;

  4104.     u = r->upstream;

  4106.     if (u->length == 0) {
  4107.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4108.                       "upstream sent more data than specified in "
  4109.                       "\"Content-Length\" header");
  4110.         return NGX_OK;
  4111.     }

  4113.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  4114.         ll = &cl->next;
  4115.     }

  4117.     cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  4118.     if (cl == NULL) {
  4119.         return NGX_ERROR;
  4120.     }

  4122.     *ll = cl;

  4124.     cl->buf->flush = 1;
  4125.     cl->buf->memory = 1;

  4127.     b = &u->buffer;

  4129.     cl->buf->pos = b->last;
  4130.     b->last += bytes;
  4131.     cl->buf->last = b->last;
  4132.     cl->buf->tag = u->output.tag;

  4134.     if (u->length == -1) {
  4135.         return NGX_OK;
  4136.     }

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

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

  4144.         cl->buf->last = cl->buf->pos + u->length;
  4145.         u->length = 0;

  4147.         return NGX_OK;
  4148.     }

  4150.     u->length -= bytes;

  4152.     return NGX_OK;
  4153. }


  4156. #if (NGX_THREADS)

  4158. static ngx_int_t
  4159. ‌ngx_http_upstream_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
  4160. {
  4161.     ngx_str_t                  name;
  4162.     ngx_event_pipe_t          *p;
  4163.     ngx_connection_t          *c;
  4164.     ngx_thread_pool_t         *tp;
  4165.     ngx_http_request_t        *r;
  4166.     ngx_http_core_loc_conf_t  *clcf;

  4168.     r = file->thread_ctx;
  4169.     p = r->upstream->pipe;

  4171.     if (r->aio) {
  4172.         /*
  4173.          * tolerate sendfile() calls if another operation is already
  4174.          * running; this can happen due to subrequests, multiple calls
  4175.          * of the next body filter from a filter, or in HTTP/2 due to
  4176.          * a write event on the main connection
  4177.          */

  4179.         c = r->connection;

  4181. #if (NGX_HTTP_V2)
  4182.         if (r->stream) {
  4183.             c = r->stream->connection->connection;
  4184.         }
  4185. #endif

  4187.         if (task == c->sendfile_task) {
  4188.             return NGX_OK;
  4189.         }
  4190.     }

  4192.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4193.     tp = clcf->thread_pool;

  4195.     if (tp == NULL) {
  4196.         if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
  4197.             != NGX_OK)
  4198.         {
  4199.             return NGX_ERROR;
  4200.         }

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

  4204.         if (tp == NULL) {
  4205.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4206.                           "thread pool \"%V\" not found", &name);
  4207.             return NGX_ERROR;
  4208.         }
  4209.     }

  4211.     task->event.data = r;
  4212.     task->event.handler = ngx_http_upstream_thread_event_handler;

  4214.     if (r->main->blocked >= NGX_HTTP_MAX_BLOCKED) {
  4215.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4216.                       "too many operations pending");
  4217.         return NGX_ERROR;
  4218.     }

  4220.     if (ngx_thread_task_post(tp, task) != NGX_OK) {
  4221.         return NGX_ERROR;
  4222.     }

  4224.     r->main->blocked++;
  4225.     r->aio = 1;
  4226.     p->aio = 1;

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

  4230.     return NGX_OK;
  4231. }


  4234. static void
  4235. ‌ngx_http_upstream_thread_event_handler(ngx_event_t *ev)
  4236. {
  4237.     ngx_connection_t    *c;
  4238.     ngx_http_request_t  *r;

  4240.     r = ev->data;
  4241.     c = r->connection;

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

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

  4248.     if (ev->timedout) {
  4249.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  4250.                       "thread operation took too long");
  4251.         ev->timedout = 0;
  4252.         return;
  4253.     }

  4255.     if (ev->timer_set) {
  4256.         ngx_del_timer(ev);
  4257.     }

  4259.     r->main->blocked--;
  4260.     r->aio = 0;

  4262. #if (NGX_HTTP_V2)

  4264.     if (r->stream) {
  4265.         /*
  4266.          * for HTTP/2, update write event to make sure processing will
  4267.          * reach the main connection to handle sendfile() in threads
  4268.          */

  4270.         c->write->ready = 1;
  4271.         c->write->active = 0;
  4272.     }

  4274. #endif

  4276.     if (r->done || r->main->terminated) {
  4277.         /*
  4278.          * trigger connection event handler if the subrequest was
  4279.          * already finalized (this can happen if the handler is used
  4280.          * for sendfile() in threads), or if the request was terminated
  4281.          */

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

  4285.     } else {
  4286.         r->write_event_handler(r);
  4287.         ngx_http_run_posted_requests(c);
  4288.     }
  4289. }

  4291. #endif


  4294. static ngx_int_t
  4295. ‌ngx_http_upstream_output_filter(void *data, ngx_chain_t *chain)
  4296. {
  4297.     ngx_int_t            rc;
  4298.     ngx_event_pipe_t    *p;
  4299.     ngx_http_request_t  *r;

  4301.     r = data;
  4302.     p = r->upstream->pipe;

  4304.     rc = ngx_http_output_filter(r, chain);

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

  4308.     return rc;
  4309. }


  4312. static void
  4313. ‌ngx_http_upstream_process_downstream(ngx_http_request_t *r)
  4314. {
  4315.     ngx_event_t          *wev;
  4316.     ngx_connection_t     *c;
  4317.     ngx_event_pipe_t     *p;
  4318.     ngx_http_upstream_t  *u;

  4320.     c = r->connection;
  4321.     u = r->upstream;
  4322.     p = u->pipe;
  4323.     wev = c->write;

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

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

  4330. #if (NGX_THREADS)
  4331.     p->aio = r->aio;
  4332. #endif

  4334.     if (wev->timedout) {

  4336.         p->downstream_error = 1;
  4337.         c->timedout = 1;
  4338.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");

  4340.     } else {

  4342.         if (wev->delayed) {

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

  4347.             if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
  4348.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4349.             }

  4351.             return;
  4352.         }

  4354.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4355.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4356.             return;
  4357.         }
  4358.     }

  4360.     ngx_http_upstream_process_request(r, u);
  4361. }


  4364. static void
  4365. ‌ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  4366.     ngx_http_upstream_t *u)
  4367. {
  4368.     ngx_event_t       *rev;
  4369.     ngx_event_pipe_t  *p;
  4370.     ngx_connection_t  *c;

  4372.     c = u->peer.connection;
  4373.     p = u->pipe;
  4374.     rev = c->read;

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

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

  4381.     if (rev->timedout) {

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

  4386.     } else {

  4388.         if (rev->delayed) {

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

  4393.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  4394.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4395.             }

  4397.             return;
  4398.         }

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

  4406.     ngx_http_upstream_process_request(r, u);
  4407. }


  4410. static void
  4411. ‌ngx_http_upstream_process_request(ngx_http_request_t *r,
  4412.     ngx_http_upstream_t *u)
  4413. {
  4414.     ngx_temp_file_t   *tf;
  4415.     ngx_event_pipe_t  *p;

  4417.     p = u->pipe;

  4419. #if (NGX_THREADS)

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

  4423.         /*
  4424.          * make sure to call ngx_event_pipe()
  4425.          * if there is an incomplete aio write
  4426.          */

  4428.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4429.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4430.             return;
  4431.         }
  4432.     }

  4434.     if (p->writing) {
  4435.         return;
  4436.     }

  4438. #endif

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

  4442.         if (u->store) {

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

  4446.                 tf = p->temp_file;

  4448.                 if (u->headers_in.status_n == NGX_HTTP_OK
  4449.                     && (p->upstream_done || p->length == -1)
  4450.                     && (u->headers_in.content_length_n == -1
  4451.                         || u->headers_in.content_length_n == tf->offset))
  4452.                 {
  4453.                     ngx_http_upstream_store(r, u);
  4454.                 }
  4455.             }
  4456.         }

  4458. #if (NGX_HTTP_CACHE)

  4460.         if (u->cacheable) {

  4462.             if (p->upstream_done) {
  4463.                 ngx_http_file_cache_update(r, p->temp_file);

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

  4467.                 tf = p->temp_file;

  4469.                 if (p->length == -1
  4470.                     && (u->headers_in.content_length_n == -1
  4471.                         || u->headers_in.content_length_n
  4472.                            == tf->offset - (off_t) r->cache->body_start))
  4473.                 {
  4474.                     ngx_http_file_cache_update(r, tf);

  4476.                 } else {
  4477.                     ngx_http_file_cache_free(r->cache, tf);
  4478.                 }

  4480.             } else if (p->upstream_error) {
  4481.                 ngx_http_file_cache_free(r->cache, p->temp_file);
  4482.             }
  4483.         }

  4485. #endif

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

  4491.             if (p->upstream_done
  4492.                 || (p->upstream_eof && p->length == -1))
  4493.             {
  4494.                 ngx_http_upstream_finalize_request(r, u, 0);
  4495.                 return;
  4496.             }

  4498.             if (p->upstream_eof) {
  4499.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4500.                               "upstream prematurely closed connection");
  4501.             }

  4503.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  4504.             return;
  4505.         }
  4506.     }

  4508.     if (p->downstream_error) {
  4509.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4510.                        "http upstream downstream error");

  4512.         if (!u->cacheable && !u->store && u->peer.connection) {
  4513.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4514.         }
  4515.     }
  4516. }


  4519. static void
  4520. ‌ngx_http_upstream_store(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4521. {
  4522.     size_t                  root;
  4523.     time_t                  lm;
  4524.     ngx_str_t               path;
  4525.     ngx_temp_file_t        *tf;
  4526.     ngx_ext_rename_file_t   ext;

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

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

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

  4534.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  4535.         if (tf == NULL) {
  4536.             return;
  4537.         }

  4539.         tf->file.fd = NGX_INVALID_FILE;
  4540.         tf->file.log = r->connection->log;
  4541.         tf->path = u->conf->temp_path;
  4542.         tf->pool = r->pool;
  4543.         tf->persistent = 1;

  4545.         if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  4546.                                  tf->persistent, tf->clean, tf->access)
  4547.             != NGX_OK)
  4548.         {
  4549.             return;
  4550.         }

  4552.         u->pipe->temp_file = tf;
  4553.     }

  4555.     ext.access = u->conf->store_access;
  4556.     ext.path_access = u->conf->store_access;
  4557.     ext.time = -1;
  4558.     ext.create_path = 1;
  4559.     ext.delete_file = 1;
  4560.     ext.log = r->connection->log;

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

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

  4567.         if (lm != NGX_ERROR) {
  4568.             ext.time = lm;
  4569.             ext.fd = tf->file.fd;
  4570.         }
  4571.     }

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

  4575.         if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  4576.             return;
  4577.         }

  4579.     } else {
  4580.         if (ngx_http_script_run(r, &path, u->conf->store_lengths->elts, 0,
  4581.                                 u->conf->store_values->elts)
  4582.             == NULL)
  4583.         {
  4584.             return;
  4585.         }
  4586.     }

  4588.     path.len--;

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

  4594.     if (path.len == 0) {
  4595.         return;
  4596.     }

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

  4600.     u->store = 0;
  4601. }


  4604. static void
  4605. ‌ngx_http_upstream_dummy_handler(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4606. {
  4607.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4608.                    "http upstream dummy handler");
  4609. }


  4612. static void
  4613. ‌ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
  4614.     ngx_uint_t ft_type)
  4615. {
  4616.     ngx_msec_t  timeout;
  4617.     ngx_uint_t  status, state;

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

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

  4624.         if (u->peer.connection) {
  4625.             u->state->bytes_sent = u->peer.connection->sent;
  4626.         }

  4628.         if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_403
  4629.             || ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404)
  4630.         {
  4631.             state = NGX_PEER_NEXT;

  4633.         } else {
  4634.             state = NGX_PEER_FAILED;
  4635.         }

  4637.         u->peer.free(&u->peer, u->peer.data, state);
  4638.         u->peer.sockaddr = NULL;

  4640. #if (NGX_HTTP_UPSTREAM_SID)
  4641.         u->peer.sid = NULL;
  4642. #endif
  4643.     }

  4645.     if (ft_type == NGX_HTTP_UPSTREAM_FT_TIMEOUT) {
  4646.         ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ETIMEDOUT,
  4647.                       "upstream timed out");
  4648.     }

  4650.     if (u->peer.cached && ft_type == NGX_HTTP_UPSTREAM_FT_ERROR) {
  4651.         /* TODO: inform balancer instead */
  4652.         u->peer.tries++;
  4653.     }

  4655.     switch (ft_type) {

  4657.     case NGX_HTTP_UPSTREAM_FT_TIMEOUT:
  4658.     case NGX_HTTP_UPSTREAM_FT_HTTP_504:
  4659.         status = NGX_HTTP_GATEWAY_TIME_OUT;
  4660.         break;

  4662.     case NGX_HTTP_UPSTREAM_FT_HTTP_500:
  4663.         status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4664.         break;

  4666.     case NGX_HTTP_UPSTREAM_FT_HTTP_503:
  4667.         status = NGX_HTTP_SERVICE_UNAVAILABLE;
  4668.         break;

  4670.     case NGX_HTTP_UPSTREAM_FT_HTTP_403:
  4671.         status = NGX_HTTP_FORBIDDEN;
  4672.         break;

  4674.     case NGX_HTTP_UPSTREAM_FT_HTTP_404:
  4675.         status = NGX_HTTP_NOT_FOUND;
  4676.         break;

  4678.     case NGX_HTTP_UPSTREAM_FT_HTTP_429:
  4679.         status = NGX_HTTP_TOO_MANY_REQUESTS;
  4680.         break;

  4682.     /*
  4683.      * NGX_HTTP_UPSTREAM_FT_BUSY_LOCK and NGX_HTTP_UPSTREAM_FT_MAX_WAITING
  4684.      * never reach here
  4685.      */

  4687.     default:
  4688.         status = NGX_HTTP_BAD_GATEWAY;
  4689.     }

  4691.     if (r->connection->error) {
  4692.         ngx_http_upstream_finalize_request(r, u,
  4693.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4694.         return;
  4695.     }

  4697.     u->state->status = status;

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

  4701.     if (u->request_sent
  4702.         && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  4703.     {
  4704.         ft_type |= NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;
  4705.     }

  4707.     if (u->peer.tries == 0
  4708.         || ((u->conf->next_upstream & ft_type) != ft_type)
  4709.         || (u->request_sent && r->request_body_no_buffering)
  4710.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  4711.     {
  4712. #if (NGX_HTTP_CACHE)

  4714.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  4715.             && ((u->conf->cache_use_stale & ft_type) || r->cache->stale_error))
  4716.         {
  4717.             ngx_int_t  rc;

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

  4721.             if (rc != NGX_OK) {
  4722.                 ngx_http_upstream_finalize_request(r, u, rc);
  4723.                 return;
  4724.             }

  4726.             u->cache_status = NGX_HTTP_CACHE_STALE;
  4727.             rc = ngx_http_upstream_cache_send(r, u);

  4729.             if (rc == NGX_DONE) {
  4730.                 return;
  4731.             }

  4733.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  4734.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4735.             }

  4737.             ngx_http_upstream_finalize_request(r, u, rc);
  4738.             return;
  4739.         }
  4740. #endif

  4742.         ngx_http_upstream_finalize_request(r, u, status);
  4743.         return;
  4744.     }

  4746.     if (u->peer.connection) {
  4747.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4748.                        "close http upstream connection: %d",
  4749.                        u->peer.connection->fd);
  4750. #if (NGX_HTTP_SSL)

  4752.         if (u->peer.connection->ssl) {
  4753.             u->peer.connection->ssl->no_wait_shutdown = 1;
  4754.             u->peer.connection->ssl->no_send_shutdown = 1;

  4756.             (void) ngx_ssl_shutdown(u->peer.connection);
  4757.         }
  4758. #endif

  4760.         if (u->peer.connection->pool) {
  4761.             ngx_destroy_pool(u->peer.connection->pool);
  4762.         }

  4764.         ngx_close_connection(u->peer.connection);
  4765.         u->peer.connection = NULL;
  4766.     }

  4768.     ngx_http_upstream_connect(r, u);
  4769. }


  4772. static void
  4773. ‌ngx_http_upstream_cleanup(void *data)
  4774. {
  4775.     ngx_http_request_t *r = data;

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

  4780.     ngx_http_upstream_finalize_request(r, r->upstream, NGX_DONE);
  4781. }


  4784. static void
  4785. ‌ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  4786.     ngx_http_upstream_t *u, ngx_int_t rc)
  4787. {
  4788.     ngx_uint_t  flush;

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

  4793.     if (u->cleanup == NULL) {
  4794.         /* the request was already finalized */
  4795.         ngx_http_finalize_request(r, NGX_DONE);
  4796.         return;
  4797.     }

  4799.     *u->cleanup = NULL;
  4800.     u->cleanup = NULL;

  4802.     if (u->resolved && u->resolved->ctx) {
  4803.         ngx_resolve_name_done(u->resolved->ctx);
  4804.         u->resolved->ctx = NULL;
  4805.     }

  4807.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  4808.         u->state->response_time = ngx_current_msec - u->start_time;

  4810.         if (u->pipe && u->pipe->read_length) {
  4811.             u->state->bytes_received += u->pipe->read_length
  4812.                                         - u->pipe->preread_size;
  4813.             u->state->response_length = u->pipe->read_length;
  4814.         }

  4816.         if (u->peer.connection) {
  4817.             u->state->bytes_sent = u->peer.connection->sent;
  4818.         }
  4819.     }

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

  4823.     if (u->peer.free && u->peer.sockaddr) {
  4824.         u->peer.free(&u->peer, u->peer.data, 0);
  4825.         u->peer.sockaddr = NULL;

  4827. #if (NGX_HTTP_UPSTREAM_SID)
  4828.         u->peer.sid = NULL;
  4829. #endif
  4830.     }

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

  4834. #if (NGX_HTTP_SSL)

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

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

  4840.             /*
  4841.              * We send the "close notify" shutdown alert to the upstream only
  4842.              * and do not wait its "close notify" shutdown alert.
  4843.              * It is acceptable according to the TLS standard.
  4844.              */

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

  4848.             (void) ngx_ssl_shutdown(u->peer.connection);
  4849.         }
  4850. #endif

  4852.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4853.                        "close http upstream connection: %d",
  4854.                        u->peer.connection->fd);

  4856.         if (u->peer.connection->pool) {
  4857.             ngx_destroy_pool(u->peer.connection->pool);
  4858.         }

  4860.         ngx_close_connection(u->peer.connection);
  4861.     }

  4863.     u->peer.connection = NULL;

  4865.     if (u->pipe) {
  4866.         u->pipe->upstream = NULL;
  4867.     }

  4869.     if (u->pipe && u->pipe->temp_file) {
  4870.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4871.                        "http upstream temp fd: %d",
  4872.                        u->pipe->temp_file->file.fd);
  4873.     }

  4875.     if (u->store && u->pipe && u->pipe->temp_file
  4876.         && u->pipe->temp_file->file.fd != NGX_INVALID_FILE)
  4877.     {
  4878.         if (ngx_delete_file(u->pipe->temp_file->file.name.data)
  4879.             == NGX_FILE_ERROR)
  4880.         {
  4881.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  4882.                           ngx_delete_file_n " \"%s\" failed",
  4883.                           u->pipe->temp_file->file.name.data);
  4884.         }
  4885.     }

  4887. #if (NGX_HTTP_CACHE)

  4889.     if (r->cache) {

  4891.         if (u->cacheable) {

  4893.             if (rc == NGX_HTTP_BAD_GATEWAY || rc == NGX_HTTP_GATEWAY_TIME_OUT) {
  4894.                 time_t  valid;

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

  4898.                 if (valid) {
  4899.                     r->cache->valid_sec = ngx_time() + valid;
  4900.                     r->cache->error = rc;
  4901.                 }
  4902.             }
  4903.         }

  4905.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  4906.     }

  4908. #endif

  4910.     r->read_event_handler = ngx_http_block_reading;

  4912.     if (rc == NGX_DECLINED) {
  4913.         return;
  4914.     }

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

  4918.     if (!u->header_sent
  4919.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  4920.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST)
  4921.     {
  4922.         ngx_http_finalize_request(r, rc);
  4923.         return;
  4924.     }

  4926.     flush = 0;

  4928.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  4929.         rc = NGX_ERROR;
  4930.         flush = 1;
  4931.     }

  4933.     if (r->header_only
  4934.         || (u->pipe && u->pipe->downstream_error))
  4935.     {
  4936.         ngx_http_finalize_request(r, rc);
  4937.         return;
  4938.     }

  4940.     if (rc == 0) {

  4942.         if (ngx_http_upstream_process_trailers(r, u) != NGX_OK) {
  4943.             ngx_http_finalize_request(r, NGX_ERROR);
  4944.             return;
  4945.         }

  4947.         rc = ngx_http_send_special(r, NGX_HTTP_LAST);

  4949.     } else if (flush) {
  4950.         r->keepalive = 0;
  4951.         rc = ngx_http_send_special(r, NGX_HTTP_FLUSH);
  4952.     }

  4954.     ngx_http_finalize_request(r, rc);
  4955. }


  4958. static ngx_int_t
  4959. ‌ngx_http_upstream_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4960.     ngx_uint_t offset)
  4961. {
  4962.     ngx_table_elt_t  **ph;

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

  4966.     if (*ph) {
  4967.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4968.                       "upstream sent duplicate header line: \"%V: %V\", "
  4969.                       "previous value: \"%V: %V\", ignored",
  4970.                       &h->key, &h->value,
  4971.                       &(*ph)->key, &(*ph)->value);
  4972.         h->hash = 0;
  4973.         return NGX_OK;
  4974.     }

  4976.     *ph = h;
  4977.     h->next = NULL;

  4979.     return NGX_OK;
  4980. }


  4983. static ngx_int_t
  4984. ‌ngx_http_upstream_process_multi_header_lines(ngx_http_request_t *r,
  4985.     ngx_table_elt_t *h, ngx_uint_t offset)
  4986. {
  4987.     ngx_table_elt_t  **ph;

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

  4991.     while (*ph) { ph = &(*ph)->next; }

  4993.     *ph = h;
  4994.     h->next = NULL;

  4996.     return NGX_OK;
  4997. }


  5000. static ngx_int_t
  5001. ‌ngx_http_upstream_ignore_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  5002.     ngx_uint_t offset)
  5003. {
  5004.     return NGX_OK;
  5005. }


  5008. static ngx_int_t
  5009. ‌ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  5010.     ngx_table_elt_t *h, ngx_uint_t offset)
  5011. {
  5012.     ngx_http_upstream_t  *u;

  5014.     u = r->upstream;

  5016.     if (u->headers_in.content_length) {
  5017.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5018.                       "upstream sent duplicate header line: \"%V: %V\", "
  5019.                       "previous value: \"%V: %V\"",
  5020.                       &h->key, &h->value,
  5021.                       &u->headers_in.content_length->key,
  5022.                       &u->headers_in.content_length->value);
  5023.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5024.     }

  5026.     if (u->headers_in.transfer_encoding) {
  5027.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5028.                       "upstream sent \"Content-Length\" and "
  5029.                       "\"Transfer-Encoding\" headers at the same time");
  5030.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5031.     }

  5033.     h->next = NULL;
  5034.     u->headers_in.content_length = h;
  5035.     u->headers_in.content_length_n = ngx_atoof(h->value.data, h->value.len);

  5037.     if (u->headers_in.content_length_n == NGX_ERROR) {
  5038.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5039.                       "upstream sent invalid \"Content-Length\" header: "
  5040.                       "\"%V: %V\"", &h->key, &h->value);
  5041.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5042.     }

  5044.     return NGX_OK;
  5045. }


  5048. static ngx_int_t
  5049. ‌ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  5050.     ngx_table_elt_t *h, ngx_uint_t offset)
  5051. {
  5052.     ngx_http_upstream_t  *u;

  5054.     u = r->upstream;

  5056.     if (u->headers_in.last_modified) {
  5057.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5058.                       "upstream sent duplicate header line: \"%V: %V\", "
  5059.                       "previous value: \"%V: %V\", ignored",
  5060.                       &h->key, &h->value,
  5061.                       &u->headers_in.last_modified->key,
  5062.                       &u->headers_in.last_modified->value);
  5063.         h->hash = 0;
  5064.         return NGX_OK;
  5065.     }

  5067.     h->next = NULL;
  5068.     u->headers_in.last_modified = h;
  5069.     u->headers_in.last_modified_time = ngx_parse_http_time(h->value.data,
  5070.                                                            h->value.len);

  5072.     return NGX_OK;
  5073. }


  5076. static ngx_int_t
  5077. ‌ngx_http_upstream_process_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5078.     ngx_uint_t offset)
  5079. {
  5080.     ngx_table_elt_t      **ph;
  5081.     ngx_http_upstream_t   *u;

  5083.     u = r->upstream;
  5084.     ph = &u->headers_in.set_cookie;

  5086.     while (*ph) { ph = &(*ph)->next; }

  5088.     *ph = h;
  5089.     h->next = NULL;

  5091. #if (NGX_HTTP_CACHE)
  5092.     if (!(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_SET_COOKIE)) {
  5093.         u->cacheable = 0;
  5094.     }
  5095. #endif

  5097.     return NGX_OK;
  5098. }


  5101. static ngx_int_t
  5102. ‌ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  5103.     ngx_table_elt_t *h, ngx_uint_t offset)
  5104. {
  5105.     ngx_table_elt_t      **ph;
  5106.     ngx_http_upstream_t   *u;

  5108.     u = r->upstream;
  5109.     ph = &u->headers_in.cache_control;

  5111.     while (*ph) { ph = &(*ph)->next; }

  5113.     *ph = h;
  5114.     h->next = NULL;

  5116. #if (NGX_HTTP_CACHE)
  5117.     {
  5118.     u_char     *p, *start, *last;
  5119.     ngx_int_t   n;

  5121.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL) {
  5122.         return NGX_OK;
  5123.     }

  5125.     if (r->cache == NULL) {
  5126.         return NGX_OK;
  5127.     }

  5129.     start = h->value.data;
  5130.     last = start + h->value.len;

  5132.     if (r->cache->valid_sec != 0 && u->headers_in.x_accel_expires != NULL) {
  5133.         goto extensions;
  5134.     }

  5136.     if (ngx_strlcasestrn(start, last, (u_char *) "no-cache", 8 - 1) != NULL
  5137.         || ngx_strlcasestrn(start, last, (u_char *) "no-store", 8 - 1) != NULL
  5138.         || ngx_strlcasestrn(start, last, (u_char *) "private", 7 - 1) != NULL)
  5139.     {
  5140.         u->headers_in.no_cache = 1;
  5141.         return NGX_OK;
  5142.     }

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

  5147.     if (p == NULL) {
  5148.         p = ngx_strlcasestrn(start, last, (u_char *) "max-age=", 8 - 1);
  5149.         offset = 8;
  5150.     }

  5152.     if (p) {
  5153.         n = ngx_http_upstream_process_delta_seconds(p + offset, last);

  5155.         if (n == NGX_ERROR) {
  5156.             u->cacheable = 0;
  5157.             return NGX_OK;
  5158.         }

  5160.         if (n == 0) {
  5161.             u->headers_in.no_cache = 1;
  5162.             return NGX_OK;
  5163.         }

  5165.         r->cache->valid_sec = ngx_min((ngx_uint_t) ngx_time() + n,
  5166.                                       NGX_MAX_INT_T_VALUE);
  5167.         u->headers_in.expired = 0;
  5168.     }

  5170. extensions:

  5172.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-while-revalidate=",
  5173.                          23 - 1);

  5175.     if (p) {
  5176.         n = ngx_http_upstream_process_delta_seconds(p + 23, last);

  5178.         if (n == NGX_ERROR) {
  5179.             u->cacheable = 0;
  5180.             return NGX_OK;
  5181.         }

  5183.         r->cache->updating_sec = n;
  5184.         r->cache->error_sec = n;
  5185.     }

  5187.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-if-error=", 15 - 1);

  5189.     if (p) {
  5190.         n = ngx_http_upstream_process_delta_seconds(p + 15, last);

  5192.         if (n == NGX_ERROR) {
  5193.             u->cacheable = 0;
  5194.             return NGX_OK;
  5195.         }

  5197.         r->cache->error_sec = n;
  5198.     }
  5199.     }
  5200. #endif

  5202.     return NGX_OK;
  5203. }


  5206. #if (NGX_HTTP_CACHE)

  5208. static ngx_int_t
  5209. ‌ngx_http_upstream_process_delta_seconds(u_char *p, u_char *last)
  5210. {
  5211.     ngx_int_t  n, cutoff, cutlim;

  5213.     cutoff = NGX_MAX_INT_T_VALUE / 10;
  5214.     cutlim = NGX_MAX_INT_T_VALUE % 10;

  5216.     n = 0;

  5218.     for ( /* void */ ; p < last; p++) {
  5219.         if (*p == ',' || *p == ';' || *p == ' ') {
  5220.             break;
  5221.         }

  5223.         if (*p < '0' || *p > '9') {
  5224.             return NGX_ERROR;
  5225.         }

  5227.         if (n >= cutoff && (n > cutoff || *p - '0' > cutlim)) {
  5228.             n = NGX_MAX_INT_T_VALUE;
  5229.             break;
  5230.         }

  5232.         n = n * 10 + (*p - '0');
  5233.     }

  5235.     return n;
  5236. }

  5238. #endif


  5241. static ngx_int_t
  5242. ‌ngx_http_upstream_process_expires(ngx_http_request_t *r, ngx_table_elt_t *h,
  5243.     ngx_uint_t offset)
  5244. {
  5245.     ngx_http_upstream_t  *u;

  5247.     u = r->upstream;

  5249.     if (u->headers_in.expires) {
  5250.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5251.                       "upstream sent duplicate header line: \"%V: %V\", "
  5252.                       "previous value: \"%V: %V\", ignored",
  5253.                       &h->key, &h->value,
  5254.                       &u->headers_in.expires->key,
  5255.                       &u->headers_in.expires->value);
  5256.         h->hash = 0;
  5257.         return NGX_OK;
  5258.     }

  5260.     u->headers_in.expires = h;
  5261.     h->next = NULL;

  5263. #if (NGX_HTTP_CACHE)
  5264.     {
  5265.     time_t  expires;

  5267.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_EXPIRES) {
  5268.         return NGX_OK;
  5269.     }

  5271.     if (r->cache == NULL) {
  5272.         return NGX_OK;
  5273.     }

  5275.     if (r->cache->valid_sec != 0) {
  5276.         return NGX_OK;
  5277.     }

  5279.     expires = ngx_parse_http_time(h->value.data, h->value.len);

  5281.     if (expires == NGX_ERROR || expires < ngx_time()) {
  5282.         u->headers_in.expired = 1;
  5283.         return NGX_OK;
  5284.     }

  5286.     r->cache->valid_sec = expires;
  5287.     }
  5288. #endif

  5290.     return NGX_OK;
  5291. }


  5294. static ngx_int_t
  5295. ‌ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  5296.     ngx_table_elt_t *h, ngx_uint_t offset)
  5297. {
  5298.     ngx_http_upstream_t  *u;

  5300.     u = r->upstream;

  5302.     if (u->headers_in.x_accel_expires) {
  5303.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5304.                       "upstream sent duplicate header line: \"%V: %V\", "
  5305.                       "previous value: \"%V: %V\", ignored",
  5306.                       &h->key, &h->value,
  5307.                       &u->headers_in.x_accel_expires->key,
  5308.                       &u->headers_in.x_accel_expires->value);
  5309.         h->hash = 0;
  5310.         return NGX_OK;
  5311.     }

  5313.     u->headers_in.x_accel_expires = h;
  5314.     h->next = NULL;

  5316. #if (NGX_HTTP_CACHE)
  5317.     {
  5318.     u_char     *p;
  5319.     size_t      len;
  5320.     ngx_int_t   n;

  5322.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES) {
  5323.         return NGX_OK;
  5324.     }

  5326.     if (r->cache == NULL) {
  5327.         return NGX_OK;
  5328.     }

  5330.     len = h->value.len;
  5331.     p = h->value.data;

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

  5336.         switch (n) {
  5337.         case 0:
  5338.             u->cacheable = 0;
  5339.             /* fall through */

  5341.         case NGX_ERROR:
  5342.             return NGX_OK;

  5344.         default:
  5345.             r->cache->valid_sec = ngx_time() + n;
  5346.             u->headers_in.no_cache = 0;
  5347.             u->headers_in.expired = 0;
  5348.             return NGX_OK;
  5349.         }
  5350.     }

  5352.     p++;
  5353.     len--;

  5355.     n = ngx_atoi(p, len);

  5357.     if (n != NGX_ERROR) {
  5358.         r->cache->valid_sec = n;
  5359.         u->headers_in.no_cache = 0;
  5360.         u->headers_in.expired = 0;
  5361.     }
  5362.     }
  5363. #endif

  5365.     return NGX_OK;
  5366. }


  5369. static ngx_int_t
  5370. ‌ngx_http_upstream_process_limit_rate(ngx_http_request_t *r, ngx_table_elt_t *h,
  5371.     ngx_uint_t offset)
  5372. {
  5373.     ngx_int_t             n;
  5374.     ngx_http_upstream_t  *u;

  5376.     u = r->upstream;

  5378.     if (u->headers_in.x_accel_limit_rate) {
  5379.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5380.                       "upstream sent duplicate header line: \"%V: %V\", "
  5381.                       "previous value: \"%V: %V\", ignored",
  5382.                       &h->key, &h->value,
  5383.                       &u->headers_in.x_accel_limit_rate->key,
  5384.                       &u->headers_in.x_accel_limit_rate->value);
  5385.         h->hash = 0;
  5386.         return NGX_OK;
  5387.     }

  5389.     u->headers_in.x_accel_limit_rate = h;
  5390.     h->next = NULL;

  5392.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE) {
  5393.         return NGX_OK;
  5394.     }

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

  5398.     if (n != NGX_ERROR) {
  5399.         r->limit_rate = (size_t) n;
  5400.         r->limit_rate_set = 1;
  5401.     }

  5403.     return NGX_OK;
  5404. }


  5407. static ngx_int_t
  5408. ‌ngx_http_upstream_process_buffering(ngx_http_request_t *r, ngx_table_elt_t *h,
  5409.     ngx_uint_t offset)
  5410. {
  5411.     u_char                c0, c1, c2;
  5412.     ngx_http_upstream_t  *u;

  5414.     u = r->upstream;

  5416.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING) {
  5417.         return NGX_OK;
  5418.     }

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

  5422.         if (h->value.len == 2) {
  5423.             c0 = ngx_tolower(h->value.data[0]);
  5424.             c1 = ngx_tolower(h->value.data[1]);

  5426.             if (c0 == 'n' && c1 == 'o') {
  5427.                 u->buffering = 0;
  5428.             }

  5430.         } else if (h->value.len == 3) {
  5431.             c0 = ngx_tolower(h->value.data[0]);
  5432.             c1 = ngx_tolower(h->value.data[1]);
  5433.             c2 = ngx_tolower(h->value.data[2]);

  5435.             if (c0 == 'y' && c1 == 'e' && c2 == 's') {
  5436.                 u->buffering = 1;
  5437.             }
  5438.         }
  5439.     }

  5441.     return NGX_OK;
  5442. }


  5445. static ngx_int_t
  5446. ‌ngx_http_upstream_process_charset(ngx_http_request_t *r, ngx_table_elt_t *h,
  5447.     ngx_uint_t offset)
  5448. {
  5449.     ngx_http_upstream_t  *u;

  5451.     u = r->upstream;

  5453.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_CHARSET) {
  5454.         return NGX_OK;
  5455.     }

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

  5459.     return NGX_OK;
  5460. }


  5463. static ngx_int_t
  5464. ‌ngx_http_upstream_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  5465.     ngx_uint_t offset)
  5466. {
  5467.     ngx_table_elt_t      **ph;
  5468.     ngx_http_upstream_t   *u;

  5470.     u = r->upstream;
  5471.     ph = &u->headers_in.connection;

  5473.     while (*ph) { ph = &(*ph)->next; }

  5475.     *ph = h;
  5476.     h->next = NULL;

  5478.     if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
  5479.                          (u_char *) "close", 5 - 1)
  5480.         != NULL)
  5481.     {
  5482.         u->headers_in.connection_close = 1;
  5483.     }

  5485.     return NGX_OK;
  5486. }


  5489. static ngx_int_t
  5490. ‌ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  5491.     ngx_table_elt_t *h, ngx_uint_t offset)
  5492. {
  5493.     ngx_http_upstream_t  *u;

  5495.     u = r->upstream;

  5497.     if (u->headers_in.transfer_encoding) {
  5498.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5499.                       "upstream sent duplicate header line: \"%V: %V\", "
  5500.                       "previous value: \"%V: %V\"",
  5501.                       &h->key, &h->value,
  5502.                       &u->headers_in.transfer_encoding->key,
  5503.                       &u->headers_in.transfer_encoding->value);
  5504.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5505.     }

  5507.     if (u->headers_in.content_length) {
  5508.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5509.                       "upstream sent \"Content-Length\" and "
  5510.                       "\"Transfer-Encoding\" headers at the same time");
  5511.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5512.     }

  5514.     u->headers_in.transfer_encoding = h;
  5515.     h->next = NULL;

  5517.     if (h->value.len == 7
  5518.         && ngx_strncasecmp(h->value.data, (u_char *) "chunked", 7) == 0)
  5519.     {
  5520.         u->headers_in.chunked = 1;

  5522.     } else {
  5523.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5524.                       "upstream sent unknown \"Transfer-Encoding\": \"%V\"",
  5525.                       &h->value);
  5526.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5527.     }

  5529.     return NGX_OK;
  5530. }


  5533. static ngx_int_t
  5534. ‌ngx_http_upstream_process_vary(ngx_http_request_t *r,
  5535.     ngx_table_elt_t *h, ngx_uint_t offset)
  5536. {
  5537.     ngx_table_elt_t      **ph;
  5538.     ngx_http_upstream_t   *u;

  5540.     u = r->upstream;
  5541.     ph = &u->headers_in.vary;

  5543.     while (*ph) { ph = &(*ph)->next; }

  5545.     *ph = h;
  5546.     h->next = NULL;

  5548. #if (NGX_HTTP_CACHE)
  5549.     {
  5550.     u_char     *p;
  5551.     size_t      len;
  5552.     ngx_str_t   vary;

  5554.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_VARY) {
  5555.         return NGX_OK;
  5556.     }

  5558.     if (r->cache == NULL || !u->cacheable) {
  5559.         return NGX_OK;
  5560.     }

  5562.     if (h->value.len == 1 && h->value.data[0] == '*') {
  5563.         u->cacheable = 0;
  5564.         return NGX_OK;
  5565.     }

  5567.     if (u->headers_in.vary->next) {

  5569.         len = 0;

  5571.         for (h = u->headers_in.vary; h; h = h->next) {
  5572.             len += h->value.len + 2;
  5573.         }

  5575.         len -= 2;

  5577.         p = ngx_pnalloc(r->pool, len);
  5578.         if (p == NULL) {
  5579.             return NGX_ERROR;
  5580.         }

  5582.         vary.len = len;
  5583.         vary.data = p;

  5585.         for (h = u->headers_in.vary; h; h = h->next) {
  5586.             p = ngx_copy(p, h->value.data, h->value.len);

  5588.             if (h->next == NULL) {
  5589.                 break;
  5590.             }

  5592.             *p++ = ','; *p++ = ' ';
  5593.         }

  5595.     } else {
  5596.         vary = h->value;
  5597.     }

  5599.     if (vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  5600.         u->cacheable = 0;
  5601.     }

  5603.     r->cache->vary = vary;
  5604.     }
  5605. #endif

  5607.     return NGX_OK;
  5608. }


  5611. static ngx_int_t
  5612. ‌ngx_http_upstream_process_priority(ngx_http_request_t *r,
  5613.     ngx_table_elt_t *h, ngx_uint_t offset)
  5614. {
  5615. #if (NGX_HTTP_V2)
  5616.     ngx_http_priority_t    priority;
  5617.     ngx_http_v2_stream_t  *stream;

  5619.     if (r != r->main) {
  5620.         return NGX_OK;
  5621.     }

  5623.     /* RFC 9218, Section 8: server hints override the client's values */

  5625.     stream = r->stream;

  5627.     if (stream == NULL) {
  5628.         return NGX_OK;
  5629.     }

  5631.     if (ngx_http_priority_parse(&h->value, &priority) != NGX_OK
  5632.         || !(priority.urgency_set || priority.incremental_set))
  5633.     {
  5634.         return NGX_OK;
  5635.     }

  5637.     stream->priority.server = priority;
  5638.     ngx_http_priority_state_update(&stream->priority);

  5640.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5641.                    "http upstream priority: u=%ud i=%ud",
  5642.                    stream->priority.effective.urgency,
  5643.                    stream->priority.effective.incremental);
  5644. #endif

  5646.     return NGX_OK;
  5647. }


  5650. static ngx_int_t
  5651. ‌ngx_http_upstream_copy_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  5652.     ngx_uint_t offset)
  5653. {
  5654.     ngx_table_elt_t  *ho, **ph;

  5656.     ho = ngx_list_push(&r->headers_out.headers);
  5657.     if (ho == NULL) {
  5658.         return NGX_ERROR;
  5659.     }

  5661.     *ho = *h;

  5663.     if (offset) {
  5664.         ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);
  5665.         *ph = ho;
  5666.         ho->next = NULL;
  5667.     }

  5669.     return NGX_OK;
  5670. }


  5673. static ngx_int_t
  5674. ‌ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  5675.     ngx_table_elt_t *h, ngx_uint_t offset)
  5676. {
  5677.     ngx_table_elt_t  *ho, **ph;

  5679.     ho = ngx_list_push(&r->headers_out.headers);
  5680.     if (ho == NULL) {
  5681.         return NGX_ERROR;
  5682.     }

  5684.     *ho = *h;

  5686.     ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);

  5688.     while (*ph) { ph = &(*ph)->next; }

  5690.     *ph = ho;
  5691.     ho->next = NULL;

  5693.     return NGX_OK;
  5694. }


  5697. static ngx_int_t
  5698. ‌ngx_http_upstream_copy_content_type(ngx_http_request_t *r, ngx_table_elt_t *h,
  5699.     ngx_uint_t offset)
  5700. {
  5701.     u_char  *p, *last;

  5703.     r->headers_out.content_type_len = h->value.len;
  5704.     r->headers_out.content_type = h->value;
  5705.     r->headers_out.content_type_lowcase = NULL;

  5707.     for (p = h->value.data; *p; p++) {

  5709.         if (*p != ';') {
  5710.             continue;
  5711.         }

  5713.         last = p;

  5715.         while (*++p == ' ') { /* void */ }

  5717.         if (*p == '\0') {
  5718.             return NGX_OK;
  5719.         }

  5721.         if (ngx_strncasecmp(p, (u_char *) "charset=", 8) != 0) {
  5722.             continue;
  5723.         }

  5725.         p += 8;

  5727.         r->headers_out.content_type_len = last - h->value.data;

  5729.         if (*p == '"') {
  5730.             p++;
  5731.         }

  5733.         last = h->value.data + h->value.len;

  5735.         if (last > p && *(last - 1) == '"') {
  5736.             last--;
  5737.         }

  5739.         r->headers_out.charset.len = last - p;
  5740.         r->headers_out.charset.data = p;

  5742.         return NGX_OK;
  5743.     }

  5745.     return NGX_OK;
  5746. }


  5749. static ngx_int_t
  5750. ‌ngx_http_upstream_copy_last_modified(ngx_http_request_t *r, ngx_table_elt_t *h,
  5751.     ngx_uint_t offset)
  5752. {
  5753.     ngx_table_elt_t  *ho;

  5755.     ho = ngx_list_push(&r->headers_out.headers);
  5756.     if (ho == NULL) {
  5757.         return NGX_ERROR;
  5758.     }

  5760.     *ho = *h;
  5761.     ho->next = NULL;

  5763.     r->headers_out.last_modified = ho;
  5764.     r->headers_out.last_modified_time =
  5765.                                     r->upstream->headers_in.last_modified_time;

  5767.     return NGX_OK;
  5768. }


  5771. static ngx_int_t
  5772. ‌ngx_http_upstream_rewrite_location(ngx_http_request_t *r, ngx_table_elt_t *h,
  5773.     ngx_uint_t offset)
  5774. {
  5775.     ngx_int_t         rc;
  5776.     ngx_table_elt_t  *ho;

  5778.     ho = ngx_list_push(&r->headers_out.headers);
  5779.     if (ho == NULL) {
  5780.         return NGX_ERROR;
  5781.     }

  5783.     *ho = *h;
  5784.     ho->next = NULL;

  5786.     if (r->upstream->rewrite_redirect) {
  5787.         rc = r->upstream->rewrite_redirect(r, ho, 0);

  5789.         if (rc == NGX_DECLINED) {
  5790.             return NGX_OK;
  5791.         }

  5793.         if (rc == NGX_OK) {
  5794.             r->headers_out.location = ho;

  5796.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5797.                            "rewritten location: \"%V\"", &ho->value);
  5798.         }

  5800.         return rc;
  5801.     }

  5803.     if (ho->value.data[0] != '/') {
  5804.         r->headers_out.location = ho;
  5805.     }

  5807.     /*
  5808.      * we do not set r->headers_out.location here to avoid handling
  5809.      * relative redirects in ngx_http_header_filter()
  5810.      */

  5812.     return NGX_OK;
  5813. }


  5816. static ngx_int_t
  5817. ‌ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r, ngx_table_elt_t *h,
  5818.     ngx_uint_t offset)
  5819. {
  5820.     u_char           *p;
  5821.     ngx_int_t         rc;
  5822.     ngx_table_elt_t  *ho;

  5824.     ho = ngx_list_push(&r->headers_out.headers);
  5825.     if (ho == NULL) {
  5826.         return NGX_ERROR;
  5827.     }

  5829.     *ho = *h;
  5830.     ho->next = NULL;

  5832.     if (r->upstream->rewrite_redirect) {

  5834.         p = ngx_strcasestrn(ho->value.data, "url=", 4 - 1);

  5836.         if (p) {
  5837.             rc = r->upstream->rewrite_redirect(r, ho, p + 4 - ho->value.data);

  5839.         } else {
  5840.             return NGX_OK;
  5841.         }

  5843.         if (rc == NGX_DECLINED) {
  5844.             return NGX_OK;
  5845.         }

  5847.         if (rc == NGX_OK) {
  5848.             r->headers_out.refresh = ho;

  5850.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5851.                            "rewritten refresh: \"%V\"", &ho->value);
  5852.         }

  5854.         return rc;
  5855.     }

  5857.     r->headers_out.refresh = ho;

  5859.     return NGX_OK;
  5860. }


  5863. static ngx_int_t
  5864. ‌ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5865.     ngx_uint_t offset)
  5866. {
  5867.     ngx_int_t         rc;
  5868.     ngx_table_elt_t  *ho;

  5870.     ho = ngx_list_push(&r->headers_out.headers);
  5871.     if (ho == NULL) {
  5872.         return NGX_ERROR;
  5873.     }

  5875.     *ho = *h;
  5876.     ho->next = NULL;

  5878.     if (r->upstream->rewrite_cookie) {
  5879.         rc = r->upstream->rewrite_cookie(r, ho);

  5881.         if (rc == NGX_DECLINED) {
  5882.             return NGX_OK;
  5883.         }

  5885. #if (NGX_DEBUG)
  5886.         if (rc == NGX_OK) {
  5887.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5888.                            "rewritten cookie: \"%V\"", &ho->value);
  5889.         }
  5890. #endif

  5892.         return rc;
  5893.     }

  5895.     return NGX_OK;
  5896. }


  5899. static ngx_int_t
  5900. ‌ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  5901.     ngx_table_elt_t *h, ngx_uint_t offset)
  5902. {
  5903.     ngx_table_elt_t  *ho;

  5905.     if (r->upstream->conf->force_ranges) {
  5906.         return NGX_OK;
  5907.     }

  5909. #if (NGX_HTTP_CACHE)

  5911.     if (r->cached) {
  5912.         r->allow_ranges = 1;
  5913.         return NGX_OK;
  5914.     }

  5916.     if (r->upstream->cacheable) {
  5917.         r->allow_ranges = 1;
  5918.         r->single_range = 1;
  5919.         return NGX_OK;
  5920.     }

  5922. #endif

  5924.     ho = ngx_list_push(&r->headers_out.headers);
  5925.     if (ho == NULL) {
  5926.         return NGX_ERROR;
  5927.     }

  5929.     *ho = *h;
  5930.     ho->next = NULL;

  5932.     r->headers_out.accept_ranges = ho;

  5934.     return NGX_OK;
  5935. }


  5938. static ngx_int_t
  5939. ‌ngx_http_upstream_copy_upgrade(ngx_http_request_t *r, ngx_table_elt_t *h,
  5940.     ngx_uint_t offset)
  5941. {
  5942.     ngx_table_elt_t  *ho;

  5944.     if (r->http_version >= NGX_HTTP_VERSION_20) {
  5945.         return NGX_OK;
  5946.     }

  5948.     ho = ngx_list_push(&r->headers_out.headers);
  5949.     if (ho == NULL) {
  5950.         return NGX_ERROR;
  5951.     }

  5953.     *ho = *h;

  5955.     return NGX_OK;
  5956. }


  5959. static ngx_int_t
  5960. ‌ngx_http_upstream_add_variables(ngx_conf_t *cf)
  5961. {
  5962.     ngx_http_variable_t  *var, *v;

  5964.     for (v = ngx_http_upstream_vars; v->name.len; v++) {
  5965.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  5966.         if (var == NULL) {
  5967.             return NGX_ERROR;
  5968.         }

  5970.         var->get_handler = v->get_handler;
  5971.         var->data = v->data;
  5972.     }

  5974.     return NGX_OK;
  5975. }


  5978. static ngx_int_t
  5979. ‌ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  5980.     ngx_http_variable_value_t *v, uintptr_t data)
  5981. {
  5982.     u_char                     *p;
  5983.     size_t                      len;
  5984.     ngx_uint_t                  i;
  5985.     ngx_http_upstream_state_t  *state;

  5987.     v->valid = 1;
  5988.     v->no_cacheable = 0;
  5989.     v->not_found = 0;

  5991.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5992.         v->not_found = 1;
  5993.         return NGX_OK;
  5994.     }

  5996.     len = 0;
  5997.     state = r->upstream_states->elts;

  5999.     for (i = 0; i < r->upstream_states->nelts; i++) {
  6000.         if (state[i].peer) {
  6001.             len += state[i].peer->len + 2;

  6003.         } else {
  6004.             len += 3;
  6005.         }
  6006.     }

  6008.     p = ngx_pnalloc(r->pool, len);
  6009.     if (p == NULL) {
  6010.         return NGX_ERROR;
  6011.     }

  6013.     v->data = p;

  6015.     i = 0;

  6017.     for ( ;; ) {
  6018.         if (state[i].peer) {
  6019.             p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
  6020.         }

  6022.         if (++i == r->upstream_states->nelts) {
  6023.             break;
  6024.         }

  6026.         if (state[i].peer) {
  6027.             *p++ = ',';
  6028.             *p++ = ' ';

  6030.         } else {
  6031.             *p++ = ' ';
  6032.             *p++ = ':';
  6033.             *p++ = ' ';

  6035.             if (++i == r->upstream_states->nelts) {
  6036.                 break;
  6037.             }

  6039.             continue;
  6040.         }
  6041.     }

  6043.     v->len = p - v->data;

  6045.     return NGX_OK;
  6046. }


  6049. static ngx_int_t
  6050. ‌ngx_http_upstream_status_variable(ngx_http_request_t *r,
  6051.     ngx_http_variable_value_t *v, uintptr_t data)
  6052. {
  6053.     u_char                     *p;
  6054.     size_t                      len;
  6055.     ngx_uint_t                  i;
  6056.     ngx_http_upstream_state_t  *state;

  6058.     v->valid = 1;
  6059.     v->no_cacheable = 0;
  6060.     v->not_found = 0;

  6062.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6063.         v->not_found = 1;
  6064.         return NGX_OK;
  6065.     }

  6067.     len = r->upstream_states->nelts * (3 + 2);

  6069.     p = ngx_pnalloc(r->pool, len);
  6070.     if (p == NULL) {
  6071.         return NGX_ERROR;
  6072.     }

  6074.     v->data = p;

  6076.     i = 0;
  6077.     state = r->upstream_states->elts;

  6079.     for ( ;; ) {
  6080.         if (state[i].status) {
  6081.             p = ngx_sprintf(p, "%ui", state[i].status);

  6083.         } else {
  6084.             *p++ = '-';
  6085.         }

  6087.         if (++i == r->upstream_states->nelts) {
  6088.             break;
  6089.         }

  6091.         if (state[i].peer) {
  6092.             *p++ = ',';
  6093.             *p++ = ' ';

  6095.         } else {
  6096.             *p++ = ' ';
  6097.             *p++ = ':';
  6098.             *p++ = ' ';

  6100.             if (++i == r->upstream_states->nelts) {
  6101.                 break;
  6102.             }

  6104.             continue;
  6105.         }
  6106.     }

  6108.     v->len = p - v->data;

  6110.     return NGX_OK;
  6111. }


  6114. static ngx_int_t
  6115. ‌ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  6116.     ngx_http_variable_value_t *v, uintptr_t data)
  6117. {
  6118.     u_char                     *p;
  6119.     size_t                      len;
  6120.     ngx_uint_t                  i;
  6121.     ngx_msec_int_t              ms;
  6122.     ngx_http_upstream_state_t  *state;

  6124.     v->valid = 1;
  6125.     v->no_cacheable = 0;
  6126.     v->not_found = 0;

  6128.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6129.         v->not_found = 1;
  6130.         return NGX_OK;
  6131.     }

  6133.     len = r->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);

  6135.     p = ngx_pnalloc(r->pool, len);
  6136.     if (p == NULL) {
  6137.         return NGX_ERROR;
  6138.     }

  6140.     v->data = p;

  6142.     i = 0;
  6143.     state = r->upstream_states->elts;

  6145.     for ( ;; ) {

  6147.         if (data == 1) {
  6148.             ms = state[i].header_time;

  6150.         } else if (data == 2) {
  6151.             ms = state[i].connect_time;

  6153.         } else {
  6154.             ms = state[i].response_time;
  6155.         }

  6157.         if (ms != -1) {
  6158.             ms = ngx_max(ms, 0);
  6159.             p = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000);

  6161.         } else {
  6162.             *p++ = '-';
  6163.         }

  6165.         if (++i == r->upstream_states->nelts) {
  6166.             break;
  6167.         }

  6169.         if (state[i].peer) {
  6170.             *p++ = ',';
  6171.             *p++ = ' ';

  6173.         } else {
  6174.             *p++ = ' ';
  6175.             *p++ = ':';
  6176.             *p++ = ' ';

  6178.             if (++i == r->upstream_states->nelts) {
  6179.                 break;
  6180.             }

  6182.             continue;
  6183.         }
  6184.     }

  6186.     v->len = p - v->data;

  6188.     return NGX_OK;
  6189. }


  6192. static ngx_int_t
  6193. ‌ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
  6194.     ngx_http_variable_value_t *v, uintptr_t data)
  6195. {
  6196.     u_char                     *p;
  6197.     size_t                      len;
  6198.     ngx_uint_t                  i;
  6199.     ngx_http_upstream_state_t  *state;

  6201.     v->valid = 1;
  6202.     v->no_cacheable = 0;
  6203.     v->not_found = 0;

  6205.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6206.         v->not_found = 1;
  6207.         return NGX_OK;
  6208.     }

  6210.     len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);

  6212.     p = ngx_pnalloc(r->pool, len);
  6213.     if (p == NULL) {
  6214.         return NGX_ERROR;
  6215.     }

  6217.     v->data = p;

  6219.     i = 0;
  6220.     state = r->upstream_states->elts;

  6222.     for ( ;; ) {

  6224.         if (data == 1) {
  6225.             p = ngx_sprintf(p, "%O", state[i].bytes_received);

  6227.         } else if (data == 2) {
  6228.             p = ngx_sprintf(p, "%O", state[i].bytes_sent);

  6230.         } else {
  6231.             p = ngx_sprintf(p, "%O", state[i].response_length);
  6232.         }

  6234.         if (++i == r->upstream_states->nelts) {
  6235.             break;
  6236.         }

  6238.         if (state[i].peer) {
  6239.             *p++ = ',';
  6240.             *p++ = ' ';

  6242.         } else {
  6243.             *p++ = ' ';
  6244.             *p++ = ':';
  6245.             *p++ = ' ';

  6247.             if (++i == r->upstream_states->nelts) {
  6248.                 break;
  6249.             }

  6251.             continue;
  6252.         }
  6253.     }

  6255.     v->len = p - v->data;

  6257.     return NGX_OK;
  6258. }


  6261. static ngx_int_t
  6262. ‌ngx_http_upstream_header_variable(ngx_http_request_t *r,
  6263.     ngx_http_variable_value_t *v, uintptr_t data)
  6264. {
  6265.     if (r->upstream == NULL) {
  6266.         v->not_found = 1;
  6267.         return NGX_OK;
  6268.     }

  6270.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  6271.                                          &r->upstream->headers_in.headers.part,
  6272.                                          sizeof("upstream_http_") - 1);
  6273. }


  6276. static ngx_int_t
  6277. ‌ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  6278.     ngx_http_variable_value_t *v, uintptr_t data)
  6279. {
  6280.     if (r->upstream == NULL) {
  6281.         v->not_found = 1;
  6282.         return NGX_OK;
  6283.     }

  6285.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  6286.                                         &r->upstream->headers_in.trailers.part,
  6287.                                         sizeof("upstream_trailer_") - 1);
  6288. }


  6291. static ngx_int_t
  6292. ‌ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  6293.     ngx_http_variable_value_t *v, uintptr_t data)
  6294. {
  6295.     ngx_str_t  *name = (ngx_str_t *) data;

  6297.     ngx_str_t   cookie, s;

  6299.     if (r->upstream == NULL) {
  6300.         v->not_found = 1;
  6301.         return NGX_OK;
  6302.     }

  6304.     s.len = name->len - (sizeof("upstream_cookie_") - 1);
  6305.     s.data = name->data + sizeof("upstream_cookie_") - 1;

  6307.     if (ngx_http_parse_set_cookie_lines(r, r->upstream->headers_in.set_cookie,
  6308.                                         &s, &cookie)
  6309.         == NULL)
  6310.     {
  6311.         v->not_found = 1;
  6312.         return NGX_OK;
  6313.     }

  6315.     v->len = cookie.len;
  6316.     v->valid = 1;
  6317.     v->no_cacheable = 0;
  6318.     v->not_found = 0;
  6319.     v->data = cookie.data;

  6321.     return NGX_OK;
  6322. }


  6325. #if (NGX_HTTP_CACHE)

  6327. static ngx_int_t
  6328. ‌ngx_http_upstream_cache_status(ngx_http_request_t *r,
  6329.     ngx_http_variable_value_t *v, uintptr_t data)
  6330. {
  6331.     ngx_uint_t  n;

  6333.     if (r->upstream == NULL || r->upstream->cache_status == 0) {
  6334.         v->not_found = 1;
  6335.         return NGX_OK;
  6336.     }

  6338.     n = r->upstream->cache_status - 1;

  6340.     v->valid = 1;
  6341.     v->no_cacheable = 0;
  6342.     v->not_found = 0;
  6343.     v->len = ngx_http_cache_status[n].len;
  6344.     v->data = ngx_http_cache_status[n].data;

  6346.     return NGX_OK;
  6347. }


  6350. static ngx_int_t
  6351. ‌ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  6352.     ngx_http_variable_value_t *v, uintptr_t data)
  6353. {
  6354.     u_char  *p;

  6356.     if (r->upstream == NULL
  6357.         || !r->upstream->conf->cache_revalidate
  6358.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6359.         || r->cache->last_modified == -1)
  6360.     {
  6361.         v->not_found = 1;
  6362.         return NGX_OK;
  6363.     }

  6365.     p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  6366.     if (p == NULL) {
  6367.         return NGX_ERROR;
  6368.     }

  6370.     v->len = ngx_http_time(p, r->cache->last_modified) - p;
  6371.     v->valid = 1;
  6372.     v->no_cacheable = 0;
  6373.     v->not_found = 0;
  6374.     v->data = p;

  6376.     return NGX_OK;
  6377. }


  6380. static ngx_int_t
  6381. ‌ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  6382.     ngx_http_variable_value_t *v, uintptr_t data)
  6383. {
  6384.     if (r->upstream == NULL
  6385.         || !r->upstream->conf->cache_revalidate
  6386.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6387.         || r->cache->etag.len == 0)
  6388.     {
  6389.         v->not_found = 1;
  6390.         return NGX_OK;
  6391.     }

  6393.     v->valid = 1;
  6394.     v->no_cacheable = 0;
  6395.     v->not_found = 0;
  6396.     v->len = r->cache->etag.len;
  6397.     v->data = r->cache->etag.data;

  6399.     return NGX_OK;
  6400. }

  6402. #endif


  6405. static char *
  6406. ‌ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  6407. {
  6408.     char                          *rv;
  6409.     void                          *mconf;
  6410.     ngx_str_t                     *value;
  6411.     ngx_url_t                      u;
  6412.     ngx_uint_t                     m;
  6413.     ngx_conf_t                     pcf;
  6414.     ngx_http_module_t             *module;
  6415.     ngx_http_conf_ctx_t           *ctx, *http_ctx;
  6416.     ngx_http_upstream_srv_conf_t  *uscf;

  6418.     ngx_memzero(&u, sizeof(ngx_url_t));

  6420.     value = cf->args->elts;
  6421.     u.host = value[1];
  6422.     u.no_resolve = 1;
  6423.     u.no_port = 1;

  6425.     uscf = ngx_http_upstream_add(cf, &u, NGX_HTTP_UPSTREAM_CREATE
  6426.                                          |NGX_HTTP_UPSTREAM_MODIFY
  6427.                                          |NGX_HTTP_UPSTREAM_WEIGHT
  6428.                                          |NGX_HTTP_UPSTREAM_MAX_CONNS
  6429.                                          |NGX_HTTP_UPSTREAM_MAX_FAILS
  6430.                                          |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  6431.                                          |NGX_HTTP_UPSTREAM_DOWN
  6432.                                          |NGX_HTTP_UPSTREAM_BACKUP);
  6433.     if (uscf == NULL) {
  6434.         return NGX_CONF_ERROR;
  6435.     }


  6438.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  6439.     if (ctx == NULL) {
  6440.         return NGX_CONF_ERROR;
  6441.     }

  6443.     http_ctx = cf->ctx;
  6444.     ctx->main_conf = http_ctx->main_conf;

  6446.     /* the upstream{}'s srv_conf */

  6448.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6449.     if (ctx->srv_conf == NULL) {
  6450.         return NGX_CONF_ERROR;
  6451.     }

  6453.     ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;

  6455.     uscf->srv_conf = ctx->srv_conf;


  6458.     /* the upstream{}'s loc_conf */

  6460.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6461.     if (ctx->loc_conf == NULL) {
  6462.         return NGX_CONF_ERROR;
  6463.     }

  6465.     for (m = 0; cf->cycle->modules[m]; m++) {
  6466.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  6467.             continue;
  6468.         }

  6470.         module = cf->cycle->modules[m]->ctx;

  6472.         if (module->create_srv_conf) {
  6473.             mconf = module->create_srv_conf(cf);
  6474.             if (mconf == NULL) {
  6475.                 return NGX_CONF_ERROR;
  6476.             }

  6478.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6479.         }

  6481.         if (module->create_loc_conf) {
  6482.             mconf = module->create_loc_conf(cf);
  6483.             if (mconf == NULL) {
  6484.                 return NGX_CONF_ERROR;
  6485.             }

  6487.             ctx->loc_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6488.         }
  6489.     }

  6491.     uscf->servers = ngx_array_create(cf->pool, 4,
  6492.                                      sizeof(ngx_http_upstream_server_t));
  6493.     if (uscf->servers == NULL) {
  6494.         return NGX_CONF_ERROR;
  6495.     }


  6498.     /* parse inside upstream{} */

  6500.     pcf = *cf;
  6501.     cf->ctx = ctx;
  6502.     cf->cmd_type = NGX_HTTP_UPS_CONF;

  6504.     rv = ngx_conf_parse(cf, NULL);

  6506.     *cf = pcf;

  6508.     if (rv != NGX_CONF_OK) {
  6509.         return rv;
  6510.     }

  6512.     if (uscf->servers->nelts == 0) {
  6513.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6514.                            "no servers are inside upstream");
  6515.         return NGX_CONF_ERROR;
  6516.     }

  6518.     return rv;
  6519. }


  6522. static char *
  6523. ‌ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6524. {
  6525.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6527.     time_t                       fail_timeout;
  6528.     ngx_str_t                   *value, s;
  6529.     ngx_url_t                    u;
  6530.     ngx_int_t                    weight, max_conns, max_fails;
  6531.     ngx_uint_t                   i;
  6532. #if (NGX_HTTP_UPSTREAM_ZONE)
  6533.     ngx_uint_t                   resolve;
  6534. #endif
  6535.     ngx_http_upstream_server_t  *us;

  6537.     us = ngx_array_push(uscf->servers);
  6538.     if (us == NULL) {
  6539.         return NGX_CONF_ERROR;
  6540.     }

  6542.     ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6544.     value = cf->args->elts;

  6546.     weight = 1;
  6547.     max_conns = 0;
  6548.     max_fails = 1;
  6549.     fail_timeout = 10;
  6550. #if (NGX_HTTP_UPSTREAM_ZONE)
  6551.     resolve = 0;
  6552. #endif

  6554.     for (i = 2; i < cf->args->nelts; i++) {

  6556.         if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {

  6558.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_WEIGHT)) {
  6559.                 goto not_supported;
  6560.             }

  6562.             weight = ngx_atoi(&value[i].data[7], value[i].len - 7);

  6564.             if (weight == NGX_ERROR || weight == 0) {
  6565.                 goto invalid;
  6566.             }

  6568.             continue;
  6569.         }

  6571.         if (ngx_strncmp(value[i].data, "max_conns=", 10) == 0) {

  6573.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_CONNS)) {
  6574.                 goto not_supported;
  6575.             }

  6577.             max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6579.             if (max_conns == NGX_ERROR) {
  6580.                 goto invalid;
  6581.             }

  6583.             continue;
  6584.         }

  6586.         if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {

  6588.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_FAILS)) {
  6589.                 goto not_supported;
  6590.             }

  6592.             max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6594.             if (max_fails == NGX_ERROR) {
  6595.                 goto invalid;
  6596.             }

  6598.             continue;
  6599.         }

  6601.         if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {

  6603.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_FAIL_TIMEOUT)) {
  6604.                 goto not_supported;
  6605.             }

  6607.             s.len = value[i].len - 13;
  6608.             s.data = &value[i].data[13];

  6610.             fail_timeout = ngx_parse_time(&s, 1);

  6612.             if (fail_timeout == (time_t) NGX_ERROR) {
  6613.                 goto invalid;
  6614.             }

  6616.             continue;
  6617.         }

  6619.         if (ngx_strcmp(value[i].data, "backup") == 0) {

  6621.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  6622.                 goto not_supported;
  6623.             }

  6625.             us->backup = 1;

  6627.             continue;
  6628.         }

  6630.         if (ngx_strcmp(value[i].data, "down") == 0) {

  6632.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6633.                 goto not_supported;
  6634.             }

  6636.             us->down = NGX_HTTP_UPSTREAM_FAILED;

  6638.             continue;
  6639.         }

  6641. #if (NGX_HTTP_UPSTREAM_STICKY)
  6642.         if (ngx_strcmp(value[i].data, "drain") == 0) {

  6644.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6645.                 goto not_supported;
  6646.             }

  6648.             us->down = NGX_HTTP_UPSTREAM_DRAINING;

  6650.             continue;
  6651.         }
  6652. #endif

  6654. #if (NGX_HTTP_UPSTREAM_SID)
  6655.         if (ngx_strncmp(value[i].data, "route=", 6) == 0) {

  6657.             us->sid.data = &value[i].data[6];
  6658.             us->sid.len = value[i].len - 6;

  6660.             if (us->sid.len == 0) {
  6661.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "route is empty");
  6662.                 return NGX_CONF_ERROR;
  6663.             }

  6665.             if (us->sid.len > NGX_HTTP_UPSTREAM_SID_LEN) {
  6666.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6667.                                    "route is longer than %d",
  6668.                                    NGX_HTTP_UPSTREAM_SID_LEN);
  6669.                 return NGX_CONF_ERROR;
  6670.             }

  6672.             continue;
  6673.         }
  6674. #endif

  6676. #if (NGX_HTTP_UPSTREAM_ZONE)
  6677.         if (ngx_strcmp(value[i].data, "resolve") == 0) {
  6678.             resolve = 1;
  6679.             continue;
  6680.         }

  6682.         if (ngx_strncmp(value[i].data, "service=", 8) == 0) {

  6684.             us->service.len = value[i].len - 8;
  6685.             us->service.data = &value[i].data[8];

  6687.             if (us->service.len == 0) {
  6688.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "service is empty");
  6689.                 return NGX_CONF_ERROR;
  6690.             }

  6692.             continue;
  6693.         }
  6694. #endif

  6696.         goto invalid;
  6697.     }

  6699.     ngx_memzero(&u, sizeof(ngx_url_t));

  6701.     u.url = value[1];
  6702.     u.default_port = 80;

  6704. #if (NGX_HTTP_UPSTREAM_ZONE)
  6705.     if (resolve) {
  6706.         /* resolve at run time */
  6707.         u.no_resolve = 1;
  6708.     }

  6710.     if (us->service.len && !resolve) {
  6711.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6712.                            "service upstream \"%V\" requires "
  6713.                            "\"resolve\" parameter",
  6714.                            &u.url);
  6715.         return NGX_CONF_ERROR;
  6716.     }

  6718. #endif

  6720.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  6721.         if (u.err) {
  6722.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6723.                                "%s in upstream \"%V\"", u.err, &u.url);
  6724.         }

  6726.         return NGX_CONF_ERROR;
  6727.     }

  6729.     us->name = u.url;

  6731. #if (NGX_HTTP_UPSTREAM_ZONE)

  6733.     if (us->service.len && !u.no_port) {
  6734.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6735.                            "service upstream \"%V\" may not have port",
  6736.                            &us->name);

  6738.         return NGX_CONF_ERROR;
  6739.     }

  6741.     if (us->service.len && u.naddrs) {
  6742.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6743.                            "service upstream \"%V\" requires domain name",
  6744.                            &us->name);

  6746.         return NGX_CONF_ERROR;
  6747.     }

  6749.     if (resolve && u.naddrs == 0) {
  6750.         ngx_addr_t  *addr;

  6752.         /* save port */

  6754.         addr = ngx_pcalloc(cf->pool, sizeof(ngx_addr_t));
  6755.         if (addr == NULL) {
  6756.             return NGX_CONF_ERROR;
  6757.         }

  6759.         addr->sockaddr = ngx_palloc(cf->pool, u.socklen);
  6760.         if (addr->sockaddr == NULL) {
  6761.             return NGX_CONF_ERROR;
  6762.         }

  6764.         ngx_memcpy(addr->sockaddr, &u.sockaddr, u.socklen);

  6766.         addr->socklen = u.socklen;

  6768.         us->addrs = addr;
  6769.         us->naddrs = 1;

  6771.         us->host = u.host;

  6773.     } else {
  6774.         us->addrs = u.addrs;
  6775.         us->naddrs = u.naddrs;
  6776.     }

  6778. #else

  6780.     us->addrs = u.addrs;
  6781.     us->naddrs = u.naddrs;

  6783. #endif

  6785.     us->weight = weight;
  6786.     us->max_conns = max_conns;
  6787.     us->max_fails = max_fails;
  6788.     us->fail_timeout = fail_timeout;

  6790.     return NGX_CONF_OK;

  6792. invalid:

  6794.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6795.                        "invalid parameter \"%V\"", &value[i]);

  6797.     return NGX_CONF_ERROR;

  6799. not_supported:

  6801.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6802.                        "balancing method does not support parameter \"%V\"",
  6803.                        &value[i]);

  6805.     return NGX_CONF_ERROR;
  6806. }


  6809. #if (NGX_HTTP_UPSTREAM_ZONE)

  6811. static char *
  6812. ‌ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6813. {
  6814.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6816.     ngx_str_t  *value;

  6818.     if (uscf->resolver) {
  6819.         return "is duplicate";
  6820.     }

  6822.     value = cf->args->elts;

  6824.     uscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  6825.     if (uscf->resolver == NULL) {
  6826.         return NGX_CONF_ERROR;
  6827.     }

  6829.     return NGX_CONF_OK;
  6830. }

  6832. #endif


  6835. ngx_http_upstream_srv_conf_t *
  6836. ‌ngx_http_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
  6837. {
  6838.     ngx_uint_t                      i;
  6839.     ngx_http_upstream_server_t     *us;
  6840.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  6841.     ngx_http_upstream_main_conf_t  *umcf;

  6843.     if (!(flags & NGX_HTTP_UPSTREAM_CREATE)) {

  6845.         if (ngx_parse_url(cf->pool, u) != NGX_OK) {
  6846.             if (u->err) {
  6847.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6848.                                    "%s in upstream \"%V\"", u->err, &u->url);
  6849.             }

  6851.             return NULL;
  6852.         }
  6853.     }

  6855.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

  6857.     uscfp = umcf->upstreams.elts;

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

  6861.         if (uscfp[i]->host.len != u->host.len
  6862.             || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
  6863.                != 0)
  6864.         {
  6865.             continue;
  6866.         }

  6868.         if ((flags & NGX_HTTP_UPSTREAM_CREATE)
  6869.              && (uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE))
  6870.         {
  6871.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6872.                                "duplicate upstream \"%V\"", &u->host);
  6873.             return NULL;
  6874.         }

  6876.         if ((uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE) && !u->no_port) {
  6877.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6878.                                "upstream \"%V\" may not have port %d",
  6879.                                &u->host, u->port);
  6880.             return NULL;
  6881.         }

  6883.         if ((flags & NGX_HTTP_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
  6884.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  6885.                           "upstream \"%V\" may not have port %d in %s:%ui",
  6886.                           &u->host, uscfp[i]->port,
  6887.                           uscfp[i]->file_name, uscfp[i]->line);
  6888.             return NULL;
  6889.         }

  6891.         if (uscfp[i]->port && u->port
  6892.             && uscfp[i]->port != u->port)
  6893.         {
  6894.             continue;
  6895.         }

  6897.         if (flags & NGX_HTTP_UPSTREAM_CREATE) {
  6898.             uscfp[i]->flags = flags;
  6899.             uscfp[i]->port = 0;
  6900.         }

  6902.         return uscfp[i];
  6903.     }

  6905.     uscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
  6906.     if (uscf == NULL) {
  6907.         return NULL;
  6908.     }

  6910.     uscf->flags = flags;
  6911.     uscf->host = u->host;
  6912.     uscf->file_name = cf->conf_file->file.name.data;
  6913.     uscf->line = cf->conf_file->line;
  6914.     uscf->port = u->port;
  6915.     uscf->no_port = u->no_port;
  6916. #if (NGX_HTTP_UPSTREAM_ZONE)
  6917.     uscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  6918. #endif

  6920.     if (u->naddrs == 1 && (u->port || u->family == AF_UNIX)) {
  6921.         uscf->servers = ngx_array_create(cf->pool, 1,
  6922.                                          sizeof(ngx_http_upstream_server_t));
  6923.         if (uscf->servers == NULL) {
  6924.             return NULL;
  6925.         }

  6927.         us = ngx_array_push(uscf->servers);
  6928.         if (us == NULL) {
  6929.             return NULL;
  6930.         }

  6932.         ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6934.         us->addrs = u->addrs;
  6935.         us->naddrs = 1;
  6936.     }

  6938.     uscfp = ngx_array_push(&umcf->upstreams);
  6939.     if (uscfp == NULL) {
  6940.         return NULL;
  6941.     }

  6943.     *uscfp = uscf;

  6945.     return uscf;
  6946. }


  6949. char *
  6950. ‌ngx_http_upstream_bind_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  6951.     void *conf)
  6952. {
  6953.     char  *p = conf;

  6955.     ngx_int_t                           rc;
  6956.     ngx_str_t                          *value;
  6957.     ngx_http_complex_value_t            cv;
  6958.     ngx_http_upstream_local_t         **plocal, *local;
  6959.     ngx_http_compile_complex_value_t    ccv;

  6961.     plocal = (ngx_http_upstream_local_t **) (p + cmd->offset);

  6963.     if (*plocal != NGX_CONF_UNSET_PTR) {
  6964.         return "is duplicate";
  6965.     }

  6967.     value = cf->args->elts;

  6969.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  6970.         *plocal = NULL;
  6971.         return NGX_CONF_OK;
  6972.     }

  6974.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  6976.     ccv.cf = cf;
  6977.     ccv.value = &value[1];
  6978.     ccv.complex_value = &cv;

  6980.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  6981.         return NGX_CONF_ERROR;
  6982.     }

  6984.     local = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_local_t));
  6985.     if (local == NULL) {
  6986.         return NGX_CONF_ERROR;
  6987.     }

  6989.     *plocal = local;

  6991.     if (cv.lengths) {
  6992.         local->value = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  6993.         if (local->value == NULL) {
  6994.             return NGX_CONF_ERROR;
  6995.         }

  6997.         *local->value = cv;

  6999.     } else {
  7000.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  7001.         if (local->addr == NULL) {
  7002.             return NGX_CONF_ERROR;
  7003.         }

  7005.         rc = ngx_parse_addr_port(cf->pool, local->addr, value[1].data,
  7006.                                  value[1].len);

  7008.         switch (rc) {
  7009.         case NGX_OK:
  7010.             local->addr->name = value[1];
  7011.             break;

  7013.         case NGX_DECLINED:
  7014.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  7015.                                "invalid address \"%V\"", &value[1]);
  7016.             /* fall through */

  7018.         default:
  7019.             return NGX_CONF_ERROR;
  7020.         }
  7021.     }

  7023.     if (cf->args->nelts > 2) {
  7024.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  7025. #if (NGX_HAVE_TRANSPARENT_PROXY)
  7026.             ngx_core_conf_t  *ccf;

  7028.             ccf = (ngx_core_conf_t *) ngx_get_conf(cf->cycle->conf_ctx,
  7029.                                                    ngx_core_module);

  7031.             ccf->transparent = 1;
  7032.             local->transparent = 1;
  7033. #else
  7034.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  7035.                                "transparent proxying is not supported "
  7036.                                "on this platform, ignored");
  7037. #endif
  7038.         } else {
  7039.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  7040.                                "invalid parameter \"%V\"", &value[2]);
  7041.             return NGX_CONF_ERROR;
  7042.         }
  7043.     }

  7045.     return NGX_CONF_OK;
  7046. }


  7049. static ngx_int_t
  7050. ‌ngx_http_upstream_set_local(ngx_http_request_t *r, ngx_http_upstream_t *u,
  7051.     ngx_http_upstream_local_t *local)
  7052. {
  7053.     ngx_int_t    rc;
  7054.     ngx_str_t    val;
  7055.     ngx_addr_t  *addr;

  7057.     if (local == NULL) {
  7058.         u->peer.local = NULL;
  7059.         return NGX_OK;
  7060.     }

  7062. #if (NGX_HAVE_TRANSPARENT_PROXY)
  7063.     u->peer.transparent = local->transparent;
  7064. #endif

  7066.     if (local->value == NULL) {
  7067.         u->peer.local = local->addr;
  7068.         return NGX_OK;
  7069.     }

  7071.     if (ngx_http_complex_value(r, local->value, &val) != NGX_OK) {
  7072.         return NGX_ERROR;
  7073.     }

  7075.     if (val.len == 0) {
  7076.         u->peer.local = NULL;
  7077.         return NGX_OK;
  7078.     }

  7080.     addr = ngx_palloc(r->pool, sizeof(ngx_addr_t));
  7081.     if (addr == NULL) {
  7082.         return NGX_ERROR;
  7083.     }

  7085.     rc = ngx_parse_addr_port(r->pool, addr, val.data, val.len);
  7086.     if (rc == NGX_ERROR) {
  7087.         return NGX_ERROR;
  7088.     }

  7090.     if (rc != NGX_OK) {
  7091.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  7092.                       "invalid local address \"%V\"", &val);
  7093.         u->peer.local = NULL;
  7094.         return NGX_OK;
  7095.     }

  7097.     addr->name = val;
  7098.     u->peer.local = addr;

  7100.     return NGX_OK;
  7101. }


  7104. char *
  7105. ‌ngx_http_upstream_param_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  7106.     void *conf)
  7107. {
  7108.     char  *p = conf;

  7110.     ngx_str_t                   *value;
  7111.     ngx_array_t                **a;
  7112.     ngx_http_upstream_param_t   *param;

  7114.     a = (ngx_array_t **) (p + cmd->offset);

  7116.     if (*a == NULL) {
  7117.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_param_t));
  7118.         if (*a == NULL) {
  7119.             return NGX_CONF_ERROR;
  7120.         }
  7121.     }

  7123.     param = ngx_array_push(*a);
  7124.     if (param == NULL) {
  7125.         return NGX_CONF_ERROR;
  7126.     }

  7128.     value = cf->args->elts;

  7130.     param->key = value[1];
  7131.     param->value = value[2];
  7132.     param->skip_empty = 0;

  7134.     if (cf->args->nelts == 4) {
  7135.         if (ngx_strcmp(value[3].data, "if_not_empty") != 0) {
  7136.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  7137.                                "invalid parameter \"%V\"", &value[3]);
  7138.             return NGX_CONF_ERROR;
  7139.         }

  7141.         param->skip_empty = 1;
  7142.     }

  7144.     return NGX_CONF_OK;
  7145. }


  7148. ngx_int_t
  7149. ‌ngx_http_upstream_hide_headers_hash(ngx_conf_t *cf,
  7150.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev,
  7151.     ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
  7152. {
  7153.     ngx_str_t       *h;
  7154.     ngx_uint_t       i, j;
  7155.     ngx_array_t      hide_headers;
  7156.     ngx_hash_key_t  *hk;

  7158.     if (conf->hide_headers == NGX_CONF_UNSET_PTR
  7159.         && conf->pass_headers == NGX_CONF_UNSET_PTR)
  7160.     {
  7161.         conf->hide_headers = prev->hide_headers;
  7162.         conf->pass_headers = prev->pass_headers;

  7164.         conf->hide_headers_hash = prev->hide_headers_hash;

  7166.         if (conf->hide_headers_hash.buckets) {
  7167.             return NGX_OK;
  7168.         }

  7170.     } else {
  7171.         if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
  7172.             conf->hide_headers = prev->hide_headers;
  7173.         }

  7175.         if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
  7176.             conf->pass_headers = prev->pass_headers;
  7177.         }
  7178.     }

  7180.     if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  7181.         != NGX_OK)
  7182.     {
  7183.         return NGX_ERROR;
  7184.     }

  7186.     for (h = default_hide_headers; h->len; h++) {
  7187.         hk = ngx_array_push(&hide_headers);
  7188.         if (hk == NULL) {
  7189.             return NGX_ERROR;
  7190.         }

  7192.         hk->key = *h;
  7193.         hk->key_hash = ngx_hash_key_lc(h->data, h->len);
  7194.         hk->value = (void *) 1;
  7195.     }

  7197.     if (conf->hide_headers != NGX_CONF_UNSET_PTR) {

  7199.         h = conf->hide_headers->elts;

  7201.         for (i = 0; i < conf->hide_headers->nelts; i++) {

  7203.             hk = hide_headers.elts;

  7205.             for (j = 0; j < hide_headers.nelts; j++) {
  7206.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  7207.                     goto exist;
  7208.                 }
  7209.             }

  7211.             hk = ngx_array_push(&hide_headers);
  7212.             if (hk == NULL) {
  7213.                 return NGX_ERROR;
  7214.             }

  7216.             hk->key = h[i];
  7217.             hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
  7218.             hk->value = (void *) 1;

  7220.         exist:

  7222.             continue;
  7223.         }
  7224.     }

  7226.     if (conf->pass_headers != NGX_CONF_UNSET_PTR) {

  7228.         h = conf->pass_headers->elts;
  7229.         hk = hide_headers.elts;

  7231.         for (i = 0; i < conf->pass_headers->nelts; i++) {
  7232.             for (j = 0; j < hide_headers.nelts; j++) {

  7234.                 if (hk[j].key.data == NULL) {
  7235.                     continue;
  7236.                 }

  7238.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  7239.                     hk[j].key.data = NULL;
  7240.                     break;
  7241.                 }
  7242.             }
  7243.         }
  7244.     }

  7246.     hash->hash = &conf->hide_headers_hash;
  7247.     hash->key = ngx_hash_key_lc;
  7248.     hash->pool = cf->pool;
  7249.     hash->temp_pool = NULL;

  7251.     if (ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts) != NGX_OK) {
  7252.         return NGX_ERROR;
  7253.     }

  7255.     /*
  7256.      * special handling to preserve conf->hide_headers_hash
  7257.      * in the "http" section to inherit it to all servers
  7258.      */

  7260.     if (prev->hide_headers_hash.buckets == NULL
  7261.         && conf->hide_headers == prev->hide_headers
  7262.         && conf->pass_headers == prev->pass_headers)
  7263.     {
  7264.         prev->hide_headers_hash = conf->hide_headers_hash;
  7265.     }

  7267.     return NGX_OK;
  7268. }


  7271. #if (NGX_HTTP_SSL)

  7273. ngx_int_t
  7274. ‌ngx_http_upstream_merge_ssl_passwords(ngx_conf_t *cf,
  7275.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev)
  7276. {
  7277.     ngx_uint_t  preserve;

  7279.     ngx_conf_merge_ptr_value(conf->ssl_passwords, prev->ssl_passwords, NULL);

  7281.     if (conf->ssl_certificate == NULL
  7282.         || conf->ssl_certificate->value.len == 0
  7283.         || conf->ssl_certificate_key == NULL)
  7284.     {
  7285.         return NGX_OK;
  7286.     }

  7288.     if (conf->ssl_certificate->lengths == NULL
  7289.         && conf->ssl_certificate_key->lengths == NULL)
  7290.     {
  7291.         if (conf->ssl_passwords && conf->ssl_passwords->pool == NULL) {
  7292.             /* un-preserve empty password list */
  7293.             conf->ssl_passwords = NULL;
  7294.         }

  7296.         return NGX_OK;
  7297.     }

  7299.     if (conf->ssl_passwords && conf->ssl_passwords->pool != cf->temp_pool) {
  7300.         /* already preserved */
  7301.         return NGX_OK;
  7302.     }

  7304.     preserve = (conf->ssl_passwords == prev->ssl_passwords) ? 1 : 0;

  7306.     conf->ssl_passwords = ngx_ssl_preserve_passwords(cf, conf->ssl_passwords);
  7307.     if (conf->ssl_passwords == NULL) {
  7308.         return NGX_ERROR;
  7309.     }

  7311.     /*
  7312.      * special handling to keep a preserved ssl_passwords copy
  7313.      * in the previous configuration to inherit it to all children
  7314.      */

  7316.     if (preserve) {
  7317.         prev->ssl_passwords = conf->ssl_passwords;
  7318.     }

  7320.     return NGX_OK;
  7321. }

  7323. #endif


  7326. static void *
  7327. ‌ngx_http_upstream_create_main_conf(ngx_conf_t *cf)
  7328. {
  7329.     ngx_http_upstream_main_conf_t  *umcf;

  7331.     umcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_main_conf_t));
  7332.     if (umcf == NULL) {
  7333.         return NULL;
  7334.     }

  7336.     if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
  7337.                        sizeof(ngx_http_upstream_srv_conf_t *))
  7338.         != NGX_OK)
  7339.     {
  7340.         return NULL;
  7341.     }

  7343.     return umcf;
  7344. }


  7347. static char *
  7348. ‌ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
  7349. {
  7350.     ngx_http_upstream_main_conf_t  *umcf = conf;

  7352.     ngx_uint_t                      i;
  7353.     ngx_array_t                     headers_in;
  7354.     ngx_hash_key_t                 *hk;
  7355.     ngx_hash_init_t                 hash;
  7356.     ngx_http_upstream_init_pt       init;
  7357.     ngx_http_upstream_header_t     *header;
  7358.     ngx_http_upstream_srv_conf_t  **uscfp;

  7360.     uscfp = umcf->upstreams.elts;

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

  7364.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:
  7365.                                             ngx_http_upstream_init_round_robin;

  7367.         if (init(cf, uscfp[i]) != NGX_OK) {
  7368.             return NGX_CONF_ERROR;
  7369.         }
  7370.     }


  7373.     /* upstream_headers_in_hash */

  7375.     if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
  7376.         != NGX_OK)
  7377.     {
  7378.         return NGX_CONF_ERROR;
  7379.     }

  7381.     for (header = ngx_http_upstream_headers_in; header->name.len; header++) {
  7382.         hk = ngx_array_push(&headers_in);
  7383.         if (hk == NULL) {
  7384.             return NGX_CONF_ERROR;
  7385.         }

  7387.         hk->key = header->name;
  7388.         hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
  7389.         hk->value = header;
  7390.     }

  7392.     hash.hash = &umcf->headers_in_hash;
  7393.     hash.key = ngx_hash_key_lc;
  7394.     hash.max_size = 512;
  7395.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  7396.     hash.name = "upstream_headers_in_hash";
  7397.     hash.pool = cf->pool;
  7398.     hash.temp_pool = NULL;

  7400.     if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
  7401.         return NGX_CONF_ERROR;
  7402.     }

  7404.     return NGX_CONF_OK;
  7405. }

One Level Up Top Level