One Level Up Top Level

src/http/ngx_http_upstream.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Functions defined

Source code


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


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


  13. #if (NGX_HTTP_CACHE)
  14. static ngx_int_t ngx_http_upstream_cache(ngx_http_request_t *r,
  15.     ngx_http_upstream_t *u);
  16. static ngx_int_t ngx_http_upstream_cache_get(ngx_http_request_t *r,
  17.     ngx_http_upstream_t *u, ngx_http_file_cache_t **cache);
  18. static ngx_int_t ngx_http_upstream_cache_send(ngx_http_request_t *r,
  19.     ngx_http_upstream_t *u);
  20. static ngx_int_t ngx_http_upstream_cache_background_update(
  21.     ngx_http_request_t *r, ngx_http_upstream_t *u);
  22. static ngx_int_t ngx_http_upstream_cache_check_range(ngx_http_request_t *r,
  23.     ngx_http_upstream_t *u);
  24. static ngx_int_t ngx_http_upstream_cache_status(ngx_http_request_t *r,
  25.     ngx_http_variable_value_t *v, uintptr_t data);
  26. static ngx_int_t ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  27.     ngx_http_variable_value_t *v, uintptr_t data);
  28. static ngx_int_t ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  29.     ngx_http_variable_value_t *v, uintptr_t data);
  30. #endif

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

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

  162. static ngx_int_t ngx_http_upstream_add_variables(ngx_conf_t *cf);
  163. static ngx_int_t ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  164.     ngx_http_variable_value_t *v, uintptr_t data);
  165. static ngx_int_t ngx_http_upstream_status_variable(ngx_http_request_t *r,
  166.     ngx_http_variable_value_t *v, uintptr_t data);
  167. static ngx_int_t ngx_http_upstream_response_time_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_length_variable(
  170.     ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data);
  171. static ngx_int_t ngx_http_upstream_header_variable(ngx_http_request_t *r,
  172.     ngx_http_variable_value_t *v, uintptr_t data);
  173. static ngx_int_t ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  174.     ngx_http_variable_value_t *v, uintptr_t data);
  175. static ngx_int_t ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  176.     ngx_http_variable_value_t *v, uintptr_t data);

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

  186. static ngx_int_t ngx_http_upstream_set_local(ngx_http_request_t *r,
  187.   ngx_http_upstream_t *u, ngx_http_upstream_local_t *local);

  189. static void *ngx_http_upstream_create_main_conf(ngx_conf_t *cf);
  190. static char *ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf);

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


  206. ‌static ngx_http_upstream_header_t  ngx_http_upstream_headers_in[] = {

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

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

  218.     { ngx_string("Content-Length"),
  219.                  ngx_http_upstream_process_content_length, 0,
  220.                  ngx_http_upstream_ignore_header_line, 0, 0 },

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

  228.     { ngx_string("Last-Modified"),
  229.                  ngx_http_upstream_process_last_modified, 0,
  230.                  ngx_http_upstream_copy_last_modified, 0, 0 },

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

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

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

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

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

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

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

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

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

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

  283.     { ngx_string("Upgrade"),
  284.                  ngx_http_upstream_ignore_header_line, 0,
  285.                  ngx_http_upstream_copy_upgrade, 0, 0 },

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

  292.     { ngx_string("Connection"),
  293.                  ngx_http_upstream_process_connection, 0,
  294.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  296.     { ngx_string("Keep-Alive"),
  297.                  ngx_http_upstream_ignore_header_line, 0,
  298.                  ngx_http_upstream_ignore_header_line, 0, 0 },

  300.     { ngx_string("Vary"),
  301.                  ngx_http_upstream_process_vary, 0,
  302.                  ngx_http_upstream_copy_header_line, 0, 0 },

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

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

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

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

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

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

  330.     { ngx_string("Transfer-Encoding"),
  331.                  ngx_http_upstream_process_transfer_encoding, 0,
  332.                  ngx_http_upstream_ignore_header_line, 0, 0 },

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

  339.     { ngx_null_string, NULL, 0, NULL, 0, 0 }
  340. };


  343. ‌static ngx_command_t  ngx_http_upstream_commands[] = {

  345.     { ngx_string("upstream"),
  346.       NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,
  347.       ngx_http_upstream,
  348.       0,
  349.       0,
  350.       NULL },

  352.     { ngx_string("server"),
  353.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  354.       ngx_http_upstream_server,
  355.       NGX_HTTP_SRV_CONF_OFFSET,
  356.       0,
  357.       NULL },

  359. #if (NGX_HTTP_UPSTREAM_ZONE)

  361.     { ngx_string("resolver"),
  362.       NGX_HTTP_UPS_CONF|NGX_CONF_1MORE,
  363.       ngx_http_upstream_resolver,
  364.       NGX_HTTP_SRV_CONF_OFFSET,
  365.       0,
  366.       NULL },

  368.     { ngx_string("resolver_timeout"),
  369.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE1,
  370.       ngx_conf_set_msec_slot,
  371.       NGX_HTTP_SRV_CONF_OFFSET,
  372.       offsetof(ngx_http_upstream_srv_conf_t, resolver_timeout),
  373.       NULL },

  375. #endif

  377.       ngx_null_command
  378. };


  381. ‌static ngx_http_module_t  ngx_http_upstream_module_ctx = {
  382.     ngx_http_upstream_add_variables,       /* preconfiguration */
  383.     NULL,                                  /* postconfiguration */

  385.     ngx_http_upstream_create_main_conf,    /* create main configuration */
  386.     ngx_http_upstream_init_main_conf,      /* init main configuration */

  388.     NULL,                                  /* create server configuration */
  389.     NULL,                                  /* merge server configuration */

  391.     NULL,                                  /* create location configuration */
  392.     NULL                                   /* merge location configuration */
  393. };


  396. ‌ngx_module_t  ngx_http_upstream_module = {
  397.     NGX_MODULE_V1,
  398.     &ngx_http_upstream_module_ctx,         /* module context */
  399.     ngx_http_upstream_commands,            /* module directives */
  400.     NGX_HTTP_MODULE,                       /* module type */
  401.     NULL,                                  /* init master */
  402.     NULL,                                  /* init module */
  403.     NULL,                                  /* init process */
  404.     NULL,                                  /* init thread */
  405.     NULL,                                  /* exit thread */
  406.     NULL,                                  /* exit process */
  407.     NULL,                                  /* exit master */
  408.     NGX_MODULE_V1_PADDING
  409. };


  412. ‌static ngx_http_variable_t  ngx_http_upstream_vars[] = {

  414.     { ngx_string("upstream_addr"), NULL,
  415.       ngx_http_upstream_addr_variable, 0,
  416.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  418.     { ngx_string("upstream_status"), NULL,
  419.       ngx_http_upstream_status_variable, 0,
  420.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  422.     { ngx_string("upstream_connect_time"), NULL,
  423.       ngx_http_upstream_response_time_variable, 2,
  424.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  426.     { ngx_string("upstream_header_time"), NULL,
  427.       ngx_http_upstream_response_time_variable, 1,
  428.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  430.     { ngx_string("upstream_response_time"), NULL,
  431.       ngx_http_upstream_response_time_variable, 0,
  432.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  434.     { ngx_string("upstream_response_length"), NULL,
  435.       ngx_http_upstream_response_length_variable, 0,
  436.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  438.     { ngx_string("upstream_bytes_received"), NULL,
  439.       ngx_http_upstream_response_length_variable, 1,
  440.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  442.     { ngx_string("upstream_bytes_sent"), NULL,
  443.       ngx_http_upstream_response_length_variable, 2,
  444.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  446. #if (NGX_HTTP_CACHE)

  448.     { ngx_string("upstream_cache_status"), NULL,
  449.       ngx_http_upstream_cache_status, 0,
  450.       NGX_HTTP_VAR_NOCACHEABLE, 0 },

  452.     { ngx_string("upstream_cache_last_modified"), NULL,
  453.       ngx_http_upstream_cache_last_modified, 0,
  454.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  456.     { ngx_string("upstream_cache_etag"), NULL,
  457.       ngx_http_upstream_cache_etag, 0,
  458.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  460. #endif

  462.     { ngx_string("upstream_http_"), NULL, ngx_http_upstream_header_variable,
  463.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  465.     { ngx_string("upstream_trailer_"), NULL, ngx_http_upstream_trailer_variable,
  466.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  468.     { ngx_string("upstream_cookie_"), NULL, ngx_http_upstream_cookie_variable,
  469.       0, NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_PREFIX, 0 },

  471.       ngx_http_null_variable
  472. };


  475. ‌static ngx_http_upstream_next_t  ngx_http_upstream_next_errors[] = {
  476.     { 500, NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  477.     { 502, NGX_HTTP_UPSTREAM_FT_HTTP_502 },
  478.     { 503, NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  479.     { 504, NGX_HTTP_UPSTREAM_FT_HTTP_504 },
  480.     { 403, NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  481.     { 404, NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  482.     { 429, NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  483.     { 0, 0 }
  484. };


  487. ‌ngx_conf_bitmask_t  ngx_http_upstream_cache_method_mask[] = {
  488.     { ngx_string("GET"), NGX_HTTP_GET },
  489.     { ngx_string("HEAD"), NGX_HTTP_HEAD },
  490.     { ngx_string("POST"), NGX_HTTP_POST },
  491.     { ngx_null_string, 0 }
  492. };


  495. ‌ngx_conf_bitmask_t  ngx_http_upstream_ignore_headers_masks[] = {
  496.     { ngx_string("X-Accel-Redirect"), NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT },
  497.     { ngx_string("X-Accel-Expires"), NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES },
  498.     { ngx_string("X-Accel-Limit-Rate"), NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE },
  499.     { ngx_string("X-Accel-Buffering"), NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING },
  500.     { ngx_string("X-Accel-Charset"), NGX_HTTP_UPSTREAM_IGN_XA_CHARSET },
  501.     { ngx_string("Expires"), NGX_HTTP_UPSTREAM_IGN_EXPIRES },
  502.     { ngx_string("Cache-Control"), NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL },
  503.     { ngx_string("Set-Cookie"), NGX_HTTP_UPSTREAM_IGN_SET_COOKIE },
  504.     { ngx_string("Vary"), NGX_HTTP_UPSTREAM_IGN_VARY },
  505.     { ngx_null_string, 0 }
  506. };


  509. ngx_int_t
  510. ‌ngx_http_upstream_create(ngx_http_request_t *r)
  511. {
  512.     ngx_http_upstream_t  *u;

  514.     u = r->upstream;

  516.     if (u && u->cleanup) {
  517.         r->main->count++;
  518.         ngx_http_upstream_cleanup(r);
  519.     }

  521.     u = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_t));
  522.     if (u == NULL) {
  523.         return NGX_ERROR;
  524.     }

  526.     r->upstream = u;

  528.     u->peer.log = r->connection->log;
  529.     u->peer.log_error = NGX_ERROR_ERR;

  531. #if (NGX_HTTP_CACHE)
  532.     r->cache = NULL;
  533. #endif

  535.     u->headers_in.content_length_n = -1;
  536.     u->headers_in.last_modified_time = -1;

  538.     return NGX_OK;
  539. }


  542. void
  543. ‌ngx_http_upstream_init(ngx_http_request_t *r)
  544. {
  545.     ngx_connection_t     *c;

  547.     c = r->connection;

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

  552. #if (NGX_HTTP_V2)
  553.     if (r->stream) {
  554.         ngx_http_upstream_init_request(r);
  555.         return;
  556.     }
  557. #endif

  559. #if (NGX_HTTP_V3)
  560.     if (c->quic) {
  561.         ngx_http_upstream_init_request(r);
  562.         return;
  563.     }
  564. #endif

  566.     if (c->read->timer_set) {
  567.         ngx_del_timer(c->read);
  568.     }

  570.     if (ngx_event_flags & NGX_USE_CLEAR_EVENT) {

  572.         if (!c->write->active) {
  573.             if (ngx_add_event(c->write, NGX_WRITE_EVENT, NGX_CLEAR_EVENT)
  574.                 == NGX_ERROR)
  575.             {
  576.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  577.                 return;
  578.             }
  579.         }
  580.     }

  582.     ngx_http_upstream_init_request(r);
  583. }


  586. static void
  587. ‌ngx_http_upstream_init_request(ngx_http_request_t *r)
  588. {
  589.     ngx_str_t                      *host;
  590.     ngx_uint_t                      i;
  591.     ngx_resolver_ctx_t             *ctx, temp;
  592.     ngx_http_cleanup_t             *cln;
  593.     ngx_http_upstream_t            *u;
  594.     ngx_http_core_loc_conf_t       *clcf;
  595.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  596.     ngx_http_upstream_main_conf_t  *umcf;

  598.     if (r->aio) {
  599.         return;
  600.     }

  602.     u = r->upstream;

  604. #if (NGX_HTTP_CACHE)

  606.     if (u->conf->cache) {
  607.         ngx_int_t  rc;

  609.         rc = ngx_http_upstream_cache(r, u);

  611.         if (rc == NGX_BUSY) {
  612.             r->write_event_handler = ngx_http_upstream_init_request;
  613.             return;
  614.         }

  616.         r->write_event_handler = ngx_http_request_empty_handler;

  618.         if (rc == NGX_ERROR) {
  619.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  620.             return;
  621.         }

  623.         if (rc == NGX_OK) {
  624.             rc = ngx_http_upstream_cache_send(r, u);

  626.             if (rc == NGX_DONE) {
  627.                 return;
  628.             }

  630.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  631.                 rc = NGX_DECLINED;
  632.                 r->cached = 0;
  633.                 u->buffer.start = NULL;
  634.                 u->cache_status = NGX_HTTP_CACHE_MISS;
  635.                 u->request_sent = 1;
  636.             }
  637.         }

  639.         if (rc != NGX_DECLINED) {
  640.             ngx_http_finalize_request(r, rc);
  641.             return;
  642.         }
  643.     }

  645. #endif

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

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

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

  654.         } else {
  655.             if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  656.                 ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  657.                 return;
  658.             }
  659.         }

  661.         r->read_event_handler = ngx_http_upstream_rd_check_broken_connection;
  662.         r->write_event_handler = ngx_http_upstream_wr_check_broken_connection;
  663.     }

  665.     if (r->request_body) {
  666.         u->request_bufs = r->request_body->bufs;
  667.     }

  669.     if (u->create_request(r) != NGX_OK) {
  670.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  671.         return;
  672.     }

  674.     if (ngx_http_upstream_set_local(r, u, u->conf->local) != NGX_OK) {
  675.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  676.         return;
  677.     }

  679.     if (u->conf->socket_keepalive) {
  680.         u->peer.so_keepalive = 1;
  681.     }

  683.     if (u->conf->socket_rcvbuf) {
  684.         u->peer.rcvbuf = (int) u->conf->socket_rcvbuf;
  685.     }

  687.     if (u->conf->socket_sndbuf) {
  688.         u->peer.sndbuf = (int) u->conf->socket_sndbuf;
  689.     }

  691.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  693.     u->output.alignment = clcf->directio_alignment;
  694.     u->output.pool = r->pool;
  695.     u->output.bufs.num = 1;
  696.     u->output.bufs.size = clcf->client_body_buffer_size;

  698.     if (u->output.output_filter == NULL) {
  699.         u->output.output_filter = ngx_chain_writer;
  700.         u->output.filter_ctx = &u->writer;
  701.     }

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

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

  707.         r->upstream_states = ngx_array_create(r->pool, 1,
  708.                                             sizeof(ngx_http_upstream_state_t));
  709.         if (r->upstream_states == NULL) {
  710.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  711.             return;
  712.         }

  714.     } else {

  716.         u->state = ngx_array_push(r->upstream_states);
  717.         if (u->state == NULL) {
  718.             ngx_http_upstream_finalize_request(r, u,
  719.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  720.             return;
  721.         }

  723.         ngx_memzero(u->state, sizeof(ngx_http_upstream_state_t));
  724.     }

  726.     cln = ngx_http_cleanup_add(r, 0);
  727.     if (cln == NULL) {
  728.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  729.         return;
  730.     }

  732.     cln->handler = ngx_http_upstream_cleanup;
  733.     cln->data = r;
  734.     u->cleanup = &cln->handler;

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

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

  740.     } else {

  742. #if (NGX_HTTP_SSL)
  743.         u->ssl_name = u->resolved->host;
  744. #endif

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

  748.         umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  750.         uscfp = umcf->upstreams.elts;

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

  754.             uscf = uscfp[i];

  756.             if (uscf->host.len == host->len
  757.                 && ((uscf->port == 0 && u->resolved->no_port)
  758.                      || uscf->port == u->resolved->port)
  759.                 && ngx_strncasecmp(uscf->host.data, host->data, host->len) == 0)
  760.             {
  761.                 goto found;
  762.             }
  763.         }

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

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

  777.             if (ngx_http_upstream_create_round_robin_peer(r, u->resolved)
  778.                 != NGX_OK)
  779.             {
  780.                 ngx_http_upstream_finalize_request(r, u,
  781.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  782.                 return;
  783.             }

  785.             ngx_http_upstream_connect(r, u);

  787.             return;
  788.         }

  790.         if (u->resolved->port == 0) {
  791.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  792.                           "no port in upstream \"%V\"", host);
  793.             ngx_http_upstream_finalize_request(r, u,
  794.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  795.             return;
  796.         }

  798.         temp.name = *host;

  800.         ctx = ngx_resolve_start(clcf->resolver, &temp);
  801.         if (ctx == NULL) {
  802.             ngx_http_upstream_finalize_request(r, u,
  803.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  804.             return;
  805.         }

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

  811.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  812.             return;
  813.         }

  815.         ctx->name = *host;
  816.         ctx->handler = ngx_http_upstream_resolve_handler;
  817.         ctx->data = r;
  818.         ctx->timeout = clcf->resolver_timeout;

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

  822.         if (ngx_resolve_name(ctx) != NGX_OK) {
  823.             u->resolved->ctx = NULL;
  824.             ngx_http_upstream_finalize_request(r, u,
  825.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  826.             return;
  827.         }

  829.         return;
  830.     }

  832. found:

  834.     if (uscf == NULL) {
  835.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  836.                       "no upstream configuration");
  837.         ngx_http_upstream_finalize_request(r, u,
  838.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  839.         return;
  840.     }

  842.     u->upstream = uscf;

  844. #if (NGX_HTTP_SSL)
  845.     u->ssl_name = uscf->host;
  846. #endif

  848.     if (uscf->peer.init(r, uscf) != NGX_OK) {
  849.         ngx_http_upstream_finalize_request(r, u,
  850.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  851.         return;
  852.     }

  854.     u->peer.start_time = ngx_current_msec;

  856.     if (u->conf->next_upstream_tries
  857.         && u->peer.tries > u->conf->next_upstream_tries)
  858.     {
  859.         u->peer.tries = u->conf->next_upstream_tries;
  860.     }

  862.     ngx_http_upstream_connect(r, u);
  863. }


  866. #if (NGX_HTTP_CACHE)

  868. static ngx_int_t
  869. ‌ngx_http_upstream_cache(ngx_http_request_t *r, ngx_http_upstream_t *u)
  870. {
  871.     ngx_int_t               rc;
  872.     ngx_http_cache_t       *c;
  873.     ngx_http_file_cache_t  *cache;

  875.     c = r->cache;

  877.     if (c == NULL) {

  879.         if (!(r->method & u->conf->cache_methods)) {
  880.             return NGX_DECLINED;
  881.         }

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

  885.         if (rc != NGX_OK) {
  886.             return rc;
  887.         }

  889.         if (r->method == NGX_HTTP_HEAD && u->conf->cache_convert_head) {
  890.             u->method = ngx_http_core_get_method;
  891.         }

  893.         if (ngx_http_file_cache_new(r) != NGX_OK) {
  894.             return NGX_ERROR;
  895.         }

  897.         if (u->create_key(r) != NGX_OK) {
  898.             return NGX_ERROR;
  899.         }

  901.         /* TODO: add keys */

  903.         ngx_http_file_cache_create_key(r);

  905.         if (r->cache->header_start + 256 > u->conf->buffer_size) {
  906.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  907.                           "%V_buffer_size %uz is not enough for cache key, "
  908.                           "it should be increased to at least %uz",
  909.                           &u->conf->module, u->conf->buffer_size,
  910.                           ngx_align(r->cache->header_start + 256, 1024));

  912.             r->cache = NULL;
  913.             return NGX_DECLINED;
  914.         }

  916.         u->cacheable = 1;

  918.         c = r->cache;

  920.         c->body_start = u->conf->buffer_size;
  921.         c->min_uses = u->conf->cache_min_uses;
  922.         c->file_cache = cache;

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

  926.         case NGX_ERROR:
  927.             return NGX_ERROR;

  929.         case NGX_DECLINED:
  930.             u->cache_status = NGX_HTTP_CACHE_BYPASS;
  931.             return NGX_DECLINED;

  933.         default: /* NGX_OK */
  934.             break;
  935.         }

  937.         c->lock = u->conf->cache_lock;
  938.         c->lock_timeout = u->conf->cache_lock_timeout;
  939.         c->lock_age = u->conf->cache_lock_age;

  941.         u->cache_status = NGX_HTTP_CACHE_MISS;
  942.     }

  944.     rc = ngx_http_file_cache_open(r);

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

  949.     switch (rc) {

  951.     case NGX_HTTP_CACHE_STALE:

  953.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  954.              || c->stale_updating) && !r->background
  955.             && u->conf->cache_background_update)
  956.         {
  957.             if (ngx_http_upstream_cache_background_update(r, u) == NGX_OK) {
  958.                 r->cache->background = 1;
  959.                 u->cache_status = rc;
  960.                 rc = NGX_OK;

  962.             } else {
  963.                 rc = NGX_ERROR;
  964.             }
  965.         }

  967.         break;

  969.     case NGX_HTTP_CACHE_UPDATING:

  971.         if (((u->conf->cache_use_stale & NGX_HTTP_UPSTREAM_FT_UPDATING)
  972.              || c->stale_updating) && !r->background)
  973.         {
  974.             u->cache_status = rc;
  975.             rc = NGX_OK;

  977.         } else {
  978.             rc = NGX_HTTP_CACHE_STALE;
  979.         }

  981.         break;

  983.     case NGX_OK:
  984.         u->cache_status = NGX_HTTP_CACHE_HIT;
  985.     }

  987.     switch (rc) {

  989.     case NGX_OK:

  991.         return NGX_OK;

  993.     case NGX_HTTP_CACHE_STALE:

  995.         c->valid_sec = 0;
  996.         c->updating_sec = 0;
  997.         c->error_sec = 0;

  999.         u->buffer.start = NULL;
  1000.         u->cache_status = NGX_HTTP_CACHE_EXPIRED;

  1002.         break;

  1004.     case NGX_DECLINED:

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

  1009.         } else {
  1010.             u->buffer.pos = u->buffer.start + c->header_start;
  1011.             u->buffer.last = u->buffer.pos;
  1012.         }

  1014.         break;

  1016.     case NGX_HTTP_CACHE_SCARCE:

  1018.         u->cacheable = 0;

  1020.         break;

  1022.     case NGX_AGAIN:

  1024.         return NGX_BUSY;

  1026.     case NGX_ERROR:

  1028.         return NGX_ERROR;

  1030.     default:

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

  1034.         u->cache_status = NGX_HTTP_CACHE_HIT;

  1036.         return rc;
  1037.     }

  1039.     if (ngx_http_upstream_cache_check_range(r, u) == NGX_DECLINED) {
  1040.         u->cacheable = 0;
  1041.     }

  1043.     r->cached = 0;

  1045.     return NGX_DECLINED;
  1046. }


  1049. static ngx_int_t
  1050. ‌ngx_http_upstream_cache_get(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1051.     ngx_http_file_cache_t **cache)
  1052. {
  1053.     ngx_str_t               *name, val;
  1054.     ngx_uint_t               i;
  1055.     ngx_http_file_cache_t  **caches;

  1057.     if (u->conf->cache_zone) {
  1058.         *cache = u->conf->cache_zone->data;
  1059.         return NGX_OK;
  1060.     }

  1062.     if (ngx_http_complex_value(r, u->conf->cache_value, &val) != NGX_OK) {
  1063.         return NGX_ERROR;
  1064.     }

  1066.     if (val.len == 0
  1067.         || (val.len == 3 && ngx_strncmp(val.data, "off", 3) == 0))
  1068.     {
  1069.         return NGX_DECLINED;
  1070.     }

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

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

  1077.         if (name->len == val.len
  1078.             && ngx_strncmp(name->data, val.data, val.len) == 0)
  1079.         {
  1080.             *cache = caches[i];
  1081.             return NGX_OK;
  1082.         }
  1083.     }

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

  1088.     return NGX_ERROR;
  1089. }


  1092. static ngx_int_t
  1093. ‌ngx_http_upstream_cache_send(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1094. {
  1095.     ngx_int_t          rc;
  1096.     ngx_http_cache_t  *c;

  1098.     r->cached = 1;
  1099.     c = r->cache;

  1101.     if (c->header_start == c->body_start) {
  1102.         r->http_version = NGX_HTTP_VERSION_9;
  1103.         return ngx_http_cache_send(r);
  1104.     }

  1106.     /* TODO: cache stack */

  1108.     u->buffer = *c->buf;
  1109.     u->buffer.pos += c->header_start;

  1111.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  1112.     u->headers_in.content_length_n = -1;
  1113.     u->headers_in.last_modified_time = -1;

  1115.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  1116.                       sizeof(ngx_table_elt_t))
  1117.         != NGX_OK)
  1118.     {
  1119.         return NGX_ERROR;
  1120.     }

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

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

  1131.     if (rc == NGX_OK) {

  1133.         if (ngx_http_upstream_process_headers(r, u) != NGX_OK) {
  1134.             return NGX_DONE;
  1135.         }

  1137.         return ngx_http_cache_send(r);
  1138.     }

  1140.     if (rc == NGX_ERROR) {
  1141.         return NGX_ERROR;
  1142.     }

  1144.     if (rc == NGX_AGAIN || rc == NGX_HTTP_UPSTREAM_EARLY_HINTS) {
  1145.         rc = NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1146.     }

  1148.     /* rc == NGX_HTTP_UPSTREAM_INVALID_HEADER */

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

  1154.     /* TODO: delete file */

  1156.     return rc;
  1157. }


  1160. static ngx_int_t
  1161. ‌ngx_http_upstream_cache_background_update(ngx_http_request_t *r,
  1162.     ngx_http_upstream_t *u)
  1163. {
  1164.     ngx_http_request_t  *sr;

  1166.     if (r == r->main) {
  1167.         r->preserve_body = 1;
  1168.     }

  1170.     if (ngx_http_subrequest(r, &r->uri, &r->args, &sr, NULL,
  1171.                             NGX_HTTP_SUBREQUEST_CLONE
  1172.                             |NGX_HTTP_SUBREQUEST_BACKGROUND)
  1173.         != NGX_OK)
  1174.     {
  1175.         return NGX_ERROR;
  1176.     }

  1178.     sr->header_only = 1;

  1180.     return NGX_OK;
  1181. }


  1184. static ngx_int_t
  1185. ‌ngx_http_upstream_cache_check_range(ngx_http_request_t *r,
  1186.     ngx_http_upstream_t *u)
  1187. {
  1188.     off_t             offset;
  1189.     u_char           *p, *start;
  1190.     ngx_table_elt_t  *h;

  1192.     h = r->headers_in.range;

  1194.     if (h == NULL
  1195.         || !u->cacheable
  1196.         || u->conf->cache_max_range_offset == NGX_MAX_OFF_T_VALUE)
  1197.     {
  1198.         return NGX_OK;
  1199.     }

  1201.     if (u->conf->cache_max_range_offset == 0) {
  1202.         return NGX_DECLINED;
  1203.     }

  1205.     if (h->value.len < 7
  1206.         || ngx_strncasecmp(h->value.data, (u_char *) "bytes=", 6) != 0)
  1207.     {
  1208.         return NGX_OK;
  1209.     }

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

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

  1215.     if (*p == '-') {
  1216.         return NGX_DECLINED;
  1217.     }

  1219.     start = p;

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

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

  1225.     if (offset >= u->conf->cache_max_range_offset) {
  1226.         return NGX_DECLINED;
  1227.     }

  1229.     return NGX_OK;
  1230. }

  1232. #endif


  1235. static void
  1236. ‌ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
  1237. {
  1238.     ngx_uint_t                     run_posted;
  1239.     ngx_connection_t              *c;
  1240.     ngx_http_request_t            *r;
  1241.     ngx_http_upstream_t           *u;
  1242.     ngx_http_upstream_resolved_t  *ur;

  1244.     run_posted = ctx->async;

  1246.     r = ctx->data;
  1247.     c = r->connection;

  1249.     u = r->upstream;
  1250.     ur = u->resolved;

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

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

  1257.     if (ctx->state) {
  1258.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1259.                       "%V could not be resolved (%i: %s)",
  1260.                       &ctx->name, ctx->state,
  1261.                       ngx_resolver_strerror(ctx->state));

  1263.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  1264.         goto failed;
  1265.     }

  1267.     ur->naddrs = ctx->naddrs;
  1268.     ur->addrs = ctx->addrs;

  1270. #if (NGX_DEBUG)
  1271.     {
  1272.     u_char      text[NGX_SOCKADDR_STRLEN];
  1273.     ngx_str_t   addr;
  1274.     ngx_uint_t  i;

  1276.     addr.data = text;

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

  1282.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1283.                        "name was resolved to %V", &addr);
  1284.     }
  1285.     }
  1286. #endif

  1288.     if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
  1289.         ngx_http_upstream_finalize_request(r, u,
  1290.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1291.         goto failed;
  1292.     }

  1294.     ngx_resolve_name_done(ctx);
  1295.     ur->ctx = NULL;

  1297.     u->peer.start_time = ngx_current_msec;

  1299.     if (u->conf->next_upstream_tries
  1300.         && u->peer.tries > u->conf->next_upstream_tries)
  1301.     {
  1302.         u->peer.tries = u->conf->next_upstream_tries;
  1303.     }

  1305.     ngx_http_upstream_connect(r, u);

  1307. failed:

  1309.     if (run_posted) {
  1310.         ngx_http_run_posted_requests(c);
  1311.     }
  1312. }


  1315. static void
  1316. ‌ngx_http_upstream_handler(ngx_event_t *ev)
  1317. {
  1318.     ngx_connection_t     *c;
  1319.     ngx_http_request_t   *r;
  1320.     ngx_http_upstream_t  *u;

  1322.     c = ev->data;
  1323.     r = c->data;

  1325.     u = r->upstream;
  1326.     c = r->connection;

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

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

  1333.     if (ev->delayed && ev->timedout) {
  1334.         ev->delayed = 0;
  1335.         ev->timedout = 0;
  1336.     }

  1338.     if (ev->write) {
  1339.         u->write_event_handler(r, u);

  1341.     } else {
  1342.         u->read_event_handler(r, u);
  1343.     }

  1345.     ngx_http_run_posted_requests(c);
  1346. }


  1349. static void
  1350. ‌ngx_http_upstream_rd_check_broken_connection(ngx_http_request_t *r)
  1351. {
  1352.     ngx_http_upstream_check_broken_connection(r, r->connection->read);
  1353. }


  1356. static void
  1357. ‌ngx_http_upstream_wr_check_broken_connection(ngx_http_request_t *r)
  1358. {
  1359.     ngx_http_upstream_check_broken_connection(r, r->connection->write);
  1360. }


  1363. static void
  1364. ‌ngx_http_upstream_check_broken_connection(ngx_http_request_t *r,
  1365.     ngx_event_t *ev)
  1366. {
  1367.     int                  n;
  1368.     char                 buf[1];
  1369.     ngx_err_t            err;
  1370.     ngx_int_t            event;
  1371.     ngx_connection_t     *c;
  1372.     ngx_http_upstream_t  *u;

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

  1378.     c = r->connection;
  1379.     u = r->upstream;

  1381.     if (c->error) {
  1382.         if ((ngx_event_flags & NGX_USE_LEVEL_EVENT) && ev->active) {

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

  1386.             if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1387.                 ngx_http_upstream_finalize_request(r, u,
  1388.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1389.                 return;
  1390.             }
  1391.         }

  1393.         if (!u->cacheable) {
  1394.             ngx_http_upstream_finalize_request(r, u,
  1395.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1396.         }

  1398.         return;
  1399.     }

  1401. #if (NGX_HTTP_V2)
  1402.     if (r->stream) {
  1403.         return;
  1404.     }
  1405. #endif

  1407. #if (NGX_HTTP_V3)

  1409.     if (c->quic) {
  1410.         if (c->write->error) {
  1411.             ngx_http_upstream_finalize_request(r, u,
  1412.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1413.         }

  1415.         return;
  1416.     }

  1418. #endif

  1420. #if (NGX_HAVE_KQUEUE)

  1422.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {

  1424.         if (!ev->pending_eof) {
  1425.             return;
  1426.         }

  1428.         ev->eof = 1;
  1429.         c->error = 1;

  1431.         if (ev->kq_errno) {
  1432.             ev->error = 1;
  1433.         }

  1435.         if (!u->cacheable && u->peer.connection) {
  1436.             ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1437.                           "kevent() reported that client prematurely closed "
  1438.                           "connection, so upstream connection is closed too");
  1439.             ngx_http_upstream_finalize_request(r, u,
  1440.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1441.             return;
  1442.         }

  1444.         ngx_log_error(NGX_LOG_INFO, ev->log, ev->kq_errno,
  1445.                       "kevent() reported that client prematurely closed "
  1446.                       "connection");

  1448.         if (u->peer.connection == NULL) {
  1449.             ngx_http_upstream_finalize_request(r, u,
  1450.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1451.         }

  1453.         return;
  1454.     }

  1456. #endif

  1458. #if (NGX_HAVE_EPOLLRDHUP)

  1460.     if ((ngx_event_flags & NGX_USE_EPOLL_EVENT) && ngx_use_epoll_rdhup) {
  1461.         socklen_t  len;

  1463.         if (!ev->pending_eof) {
  1464.             return;
  1465.         }

  1467.         ev->eof = 1;
  1468.         c->error = 1;

  1470.         err = 0;
  1471.         len = sizeof(ngx_err_t);

  1473.         /*
  1474.          * BSDs and Linux return 0 and set a pending error in err
  1475.          * Solaris returns -1 and sets errno
  1476.          */

  1478.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  1479.             == -1)
  1480.         {
  1481.             err = ngx_socket_errno;
  1482.         }

  1484.         if (err) {
  1485.             ev->error = 1;
  1486.         }

  1488.         if (!u->cacheable && u->peer.connection) {
  1489.             ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1490.                         "epoll_wait() reported that client prematurely closed "
  1491.                         "connection, so upstream connection is closed too");
  1492.             ngx_http_upstream_finalize_request(r, u,
  1493.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1494.             return;
  1495.         }

  1497.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1498.                       "epoll_wait() reported that client prematurely closed "
  1499.                       "connection");

  1501.         if (u->peer.connection == NULL) {
  1502.             ngx_http_upstream_finalize_request(r, u,
  1503.                                                NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1504.         }

  1506.         return;
  1507.     }

  1509. #endif

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

  1513.     err = ngx_socket_errno;

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

  1518.     if (ev->write && (n >= 0 || err == NGX_EAGAIN)) {
  1519.         return;
  1520.     }

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

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

  1526.         if (ngx_del_event(ev, event, 0) != NGX_OK) {
  1527.             ngx_http_upstream_finalize_request(r, u,
  1528.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1529.             return;
  1530.         }
  1531.     }

  1533.     if (n > 0) {
  1534.         return;
  1535.     }

  1537.     if (n == -1) {
  1538.         if (err == NGX_EAGAIN) {
  1539.             return;
  1540.         }

  1542.         ev->error = 1;

  1544.     } else { /* n == 0 */
  1545.         err = 0;
  1546.     }

  1548.     ev->eof = 1;
  1549.     c->error = 1;

  1551.     if (!u->cacheable && u->peer.connection) {
  1552.         ngx_log_error(NGX_LOG_INFO, ev->log, err,
  1553.                       "client prematurely closed connection, "
  1554.                       "so upstream connection is closed too");
  1555.         ngx_http_upstream_finalize_request(r, u,
  1556.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1557.         return;
  1558.     }

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

  1563.     if (u->peer.connection == NULL) {
  1564.         ngx_http_upstream_finalize_request(r, u,
  1565.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  1566.     }
  1567. }


  1570. static void
  1571. ‌ngx_http_upstream_connect(ngx_http_request_t *r, ngx_http_upstream_t *u)
  1572. {
  1573.     ngx_int_t                  rc;
  1574.     ngx_connection_t          *c;
  1575.     ngx_http_core_loc_conf_t  *clcf;

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

  1579.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  1580.         u->state->response_time = ngx_current_msec - u->start_time;
  1581.     }

  1583.     u->state = ngx_array_push(r->upstream_states);
  1584.     if (u->state == NULL) {
  1585.         ngx_http_upstream_finalize_request(r, u,
  1586.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1587.         return;
  1588.     }

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

  1592.     u->start_time = ngx_current_msec;

  1594.     u->state->response_time = (ngx_msec_t) -1;
  1595.     u->state->connect_time = (ngx_msec_t) -1;
  1596.     u->state->header_time = (ngx_msec_t) -1;

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

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

  1603.     if (rc == NGX_ERROR) {
  1604.         ngx_http_upstream_finalize_request(r, u,
  1605.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1606.         return;
  1607.     }

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

  1611. #if (NGX_HTTP_UPSTREAM_ZONE)
  1612.     if (u->upstream && u->upstream->shm_zone
  1613.         && (u->upstream->flags & NGX_HTTP_UPSTREAM_MODIFY))
  1614.     {
  1615.         u->state->peer = ngx_palloc(r->pool,
  1616.                                     sizeof(ngx_str_t) + u->peer.name->len);
  1617.         if (u->state->peer == NULL) {
  1618.             ngx_http_upstream_finalize_request(r, u,
  1619.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1620.             return;
  1621.         }

  1623.         u->state->peer->len = u->peer.name->len;
  1624.         u->state->peer->data = (u_char *) (u->state->peer + 1);
  1625.         ngx_memcpy(u->state->peer->data, u->peer.name->data, u->peer.name->len);

  1627.         u->peer.name = u->state->peer;
  1628.     }
  1629. #endif

  1631.     if (rc == NGX_BUSY) {
  1632.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "no live upstreams");
  1633.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_NOLIVE);
  1634.         return;
  1635.     }

  1637.     if (rc == NGX_DECLINED) {
  1638.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1639.         return;
  1640.     }

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

  1644.     c = u->peer.connection;

  1646.     c->requests++;

  1648.     c->data = r;

  1650.     c->write->handler = ngx_http_upstream_handler;
  1651.     c->read->handler = ngx_http_upstream_handler;

  1653.     u->write_event_handler = ngx_http_upstream_send_request_handler;
  1654.     u->read_event_handler = ngx_http_upstream_process_header;

  1656.     c->sendfile &= r->connection->sendfile;
  1657.     u->output.sendfile = c->sendfile;

  1659.     if (r->connection->tcp_nopush == NGX_TCP_NOPUSH_DISABLED) {
  1660.         c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
  1661.     }

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

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

  1667.         c->pool = ngx_create_pool(128, r->connection->log);
  1668.         if (c->pool == NULL) {
  1669.             ngx_http_upstream_finalize_request(r, u,
  1670.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1671.             return;
  1672.         }
  1673.     }

  1675.     c->log = r->connection->log;
  1676.     c->pool->log = c->log;
  1677.     c->read->log = c->log;
  1678.     c->write->log = c->log;

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

  1682.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1684.     u->writer.out = NULL;
  1685.     u->writer.last = &u->writer.out;
  1686.     u->writer.connection = c;
  1687.     u->writer.limit = clcf->sendfile_max_chunk;

  1689.     if (u->request_sent || u->response_received) {
  1690.         if (ngx_http_upstream_reinit(r, u) != NGX_OK) {
  1691.             ngx_http_upstream_finalize_request(r, u,
  1692.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1693.             return;
  1694.         }
  1695.     }

  1697.     if (r->request_body
  1698.         && r->request_body->buf
  1699.         && r->request_body->temp_file
  1700.         && r == r->main)
  1701.     {
  1702.         /*
  1703.          * the r->request_body->buf can be reused for one request only,
  1704.          * the subrequests should allocate their own temporary bufs
  1705.          */

  1707.         u->output.free = ngx_alloc_chain_link(r->pool);
  1708.         if (u->output.free == NULL) {
  1709.             ngx_http_upstream_finalize_request(r, u,
  1710.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1711.             return;
  1712.         }

  1714.         u->output.free->buf = r->request_body->buf;
  1715.         u->output.free->next = NULL;
  1716.         u->output.allocated = 1;

  1718.         r->request_body->buf->pos = r->request_body->buf->start;
  1719.         r->request_body->buf->last = r->request_body->buf->start;
  1720.         r->request_body->buf->tag = u->output.tag;
  1721.     }

  1723.     u->request_sent = 0;
  1724.     u->request_body_sent = 0;
  1725.     u->request_body_blocked = 0;
  1726.     u->response_received = 0;

  1728.     if (rc == NGX_AGAIN) {
  1729.         ngx_add_timer(c->write, u->conf->connect_timeout);
  1730.         return;
  1731.     }

  1733. #if (NGX_HTTP_SSL)

  1735.     if (u->ssl && c->ssl == NULL) {
  1736.         ngx_http_upstream_ssl_init_connection(r, u, c);
  1737.         return;
  1738.     }

  1740. #endif

  1742.     ngx_http_upstream_send_request(r, u, 1);
  1743. }


  1746. #if (NGX_HTTP_SSL)

  1748. static void
  1749. ‌ngx_http_upstream_ssl_init_connection(ngx_http_request_t *r,
  1750.     ngx_http_upstream_t *u, ngx_connection_t *c)
  1751. {
  1752.     ngx_int_t                  rc;
  1753.     ngx_http_core_loc_conf_t  *clcf;

  1755.     if (ngx_http_upstream_test_connect(c) != NGX_OK) {
  1756.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1757.         return;
  1758.     }

  1760.     if (ngx_ssl_create_connection(u->conf->ssl, c,
  1761.                                   NGX_SSL_BUFFER|NGX_SSL_CLIENT)
  1762.         != NGX_OK)
  1763.     {
  1764.         ngx_http_upstream_finalize_request(r, u,
  1765.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  1766.         return;
  1767.     }

  1769.     if (u->conf->ssl_server_name || u->conf->ssl_verify) {
  1770.         if (ngx_http_upstream_ssl_name(r, u, c) != NGX_OK) {
  1771.             ngx_http_upstream_finalize_request(r, u,
  1772.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1773.             return;
  1774.         }
  1775.     }

  1777.     if (u->conf->ssl_certificate
  1778.         && u->conf->ssl_certificate->value.len
  1779.         && (u->conf->ssl_certificate->lengths
  1780.             || u->conf->ssl_certificate_key->lengths))
  1781.     {
  1782.         if (ngx_http_upstream_ssl_certificate(r, u, c) != NGX_OK) {
  1783.             ngx_http_upstream_finalize_request(r, u,
  1784.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1785.             return;
  1786.         }
  1787.     }

  1789. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  1791.     if (u->ssl_alpn_protocol.len) {
  1792.         if (SSL_set_alpn_protos(c->ssl->connection, u->ssl_alpn_protocol.data,
  1793.                                 u->ssl_alpn_protocol.len)
  1794.             != 0)
  1795.         {
  1796.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  1797.                           "SSL_set_alpn_protos() failed");
  1798.             ngx_http_upstream_finalize_request(r, u,
  1799.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1800.             return;
  1801.         }
  1802.     }

  1804. #endif

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

  1809.         if (u->peer.set_session(&u->peer, u->peer.data) != NGX_OK) {
  1810.             ngx_http_upstream_finalize_request(r, u,
  1811.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1812.             return;
  1813.         }

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

  1817.         clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1819.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  1820.             ngx_http_upstream_finalize_request(r, u,
  1821.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  1822.             return;
  1823.         }
  1824.     }

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

  1828.     rc = ngx_ssl_handshake(c);

  1830.     if (rc == NGX_AGAIN) {

  1832.         if (!c->write->timer_set) {
  1833.             ngx_add_timer(c->write, u->conf->connect_timeout);
  1834.         }

  1836.         c->ssl->handler = ngx_http_upstream_ssl_handshake_handler;
  1837.         return;
  1838.     }

  1840.     ngx_http_upstream_ssl_handshake(r, u, c);
  1841. }


  1844. static void
  1845. ‌ngx_http_upstream_ssl_handshake_handler(ngx_connection_t *c)
  1846. {
  1847.     ngx_http_request_t   *r;
  1848.     ngx_http_upstream_t  *u;

  1850.     r = c->data;

  1852.     u = r->upstream;
  1853.     c = r->connection;

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

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

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

  1863.     ngx_http_run_posted_requests(c);
  1864. }


  1867. static void
  1868. ‌ngx_http_upstream_ssl_handshake(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1869.     ngx_connection_t *c)
  1870. {
  1871.     long  rc;

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

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

  1878.             if (rc != X509_V_OK) {
  1879.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1880.                               "upstream SSL certificate verify error: (%l:%s)",
  1881.                               rc, X509_verify_cert_error_string(rc));
  1882.                 goto failed;
  1883.             }

  1885.             if (ngx_ssl_check_host(c, &u->ssl_name) != NGX_OK) {
  1886.                 ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1887.                               "upstream SSL certificate does not match \"%V\"",
  1888.                               &u->ssl_name);
  1889.                 goto failed;
  1890.             }
  1891.         }

  1893.         if (!c->ssl->sendfile) {
  1894.             c->sendfile = 0;
  1895.             u->output.sendfile = 0;
  1896.         }

  1898.         c->write->handler = ngx_http_upstream_handler;
  1899.         c->read->handler = ngx_http_upstream_handler;

  1901.         ngx_http_upstream_send_request(r, u, 1);

  1903.         return;
  1904.     }

  1906.     if (c->write->timedout) {
  1907.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  1908.         return;
  1909.     }

  1911. failed:

  1913.     ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  1914. }


  1917. static void
  1918. ‌ngx_http_upstream_ssl_save_session(ngx_connection_t *c)
  1919. {
  1920.     ngx_http_request_t   *r;
  1921.     ngx_http_upstream_t  *u;

  1923.     if (c->idle) {
  1924.         return;
  1925.     }

  1927.     r = c->data;

  1929.     u = r->upstream;
  1930.     c = r->connection;

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

  1934.     u->peer.save_session(&u->peer, u->peer.data);
  1935. }


  1938. static ngx_int_t
  1939. ‌ngx_http_upstream_ssl_name(ngx_http_request_t *r, ngx_http_upstream_t *u,
  1940.     ngx_connection_t *c)
  1941. {
  1942.     u_char     *p, *last;
  1943.     ngx_str_t   name;

  1945.     if (u->conf->ssl_name) {
  1946.         if (ngx_http_complex_value(r, u->conf->ssl_name, &name) != NGX_OK) {
  1947.             return NGX_ERROR;
  1948.         }

  1950.     } else {
  1951.         name = u->ssl_name;
  1952.     }

  1954.     if (name.len == 0) {
  1955.         goto done;
  1956.     }

  1958.     /*
  1959.      * ssl name here may contain port, notably if derived from $proxy_host
  1960.      * or $http_host; we have to strip it
  1961.      */

  1963.     p = name.data;
  1964.     last = name.data + name.len;

  1966.     if (*p == '[') {
  1967.         p = ngx_strlchr(p, last, ']');

  1969.         if (p == NULL) {
  1970.             p = name.data;
  1971.         }
  1972.     }

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

  1976.     if (p != NULL) {
  1977.         name.len = p - name.data;
  1978.     }

  1980.     if (!u->conf->ssl_server_name) {
  1981.         goto done;
  1982.     }

  1984. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

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

  1988.     if (name.len == 0 || *name.data == '[') {
  1989.         goto done;
  1990.     }

  1992.     if (ngx_inet_addr(name.data, name.len) != INADDR_NONE) {
  1993.         goto done;
  1994.     }

  1996.     /*
  1997.      * SSL_set_tlsext_host_name() needs a null-terminated string,
  1998.      * hence we explicitly null-terminate name here
  1999.      */

  2001.     p = ngx_pnalloc(r->pool, name.len + 1);
  2002.     if (p == NULL) {
  2003.         return NGX_ERROR;
  2004.     }

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

  2008.     name.data = p;

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

  2013.     if (SSL_set_tlsext_host_name(c->ssl->connection,
  2014.                                  (char *) name.data)
  2015.         == 0)
  2016.     {
  2017.         ngx_ssl_error(NGX_LOG_ERR, r->connection->log, 0,
  2018.                       "SSL_set_tlsext_host_name(\"%s\") failed", name.data);
  2019.         return NGX_ERROR;
  2020.     }

  2022. #endif

  2024. done:

  2026.     u->ssl_name = name;

  2028.     return NGX_OK;
  2029. }


  2032. static ngx_int_t
  2033. ‌ngx_http_upstream_ssl_certificate(ngx_http_request_t *r,
  2034.     ngx_http_upstream_t *u, ngx_connection_t *c)
  2035. {
  2036.     ngx_str_t  cert, key;

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

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

  2047.     if (*cert.data == '\0') {
  2048.         return NGX_OK;
  2049.     }

  2051.     if (ngx_http_complex_value(r, u->conf->ssl_certificate_key, &key)
  2052.         != NGX_OK)
  2053.     {
  2054.         return NGX_ERROR;
  2055.     }

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

  2060.     if (ngx_ssl_connection_certificate(c, r->pool, &cert, &key,
  2061.                                        u->conf->ssl_certificate_cache,
  2062.                                        u->conf->ssl_passwords)
  2063.         != NGX_OK)
  2064.     {
  2065.         return NGX_ERROR;
  2066.     }

  2068.     return NGX_OK;
  2069. }

  2071. #endif


  2074. static ngx_int_t
  2075. ‌ngx_http_upstream_reinit(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2076. {
  2077.     off_t         file_pos;
  2078.     ngx_chain_t  *cl;

  2080.     if (u->reinit_request(r) != NGX_OK) {
  2081.         return NGX_ERROR;
  2082.     }

  2084.     u->early_hints_length = 0;
  2085.     u->keepalive = 0;
  2086.     u->upgrade = 0;
  2087.     u->error = 0;

  2089.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2090.     u->headers_in.content_length_n = -1;
  2091.     u->headers_in.last_modified_time = -1;

  2093.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2094.                       sizeof(ngx_table_elt_t))
  2095.         != NGX_OK)
  2096.     {
  2097.         return NGX_ERROR;
  2098.     }

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

  2107.     /* reinit the request chain */

  2109.     file_pos = 0;

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

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

  2116.         if (cl->buf->in_file) {
  2117.             cl->buf->file_pos = file_pos;
  2118.             file_pos = cl->buf->file_last;
  2119.         }
  2120.     }

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

  2124.     if (r->request_body && r->request_body->temp_file
  2125.         && r != r->main && u->output.buf)
  2126.     {
  2127.         u->output.free = ngx_alloc_chain_link(r->pool);
  2128.         if (u->output.free == NULL) {
  2129.             return NGX_ERROR;
  2130.         }

  2132.         u->output.free->buf = u->output.buf;
  2133.         u->output.free->next = NULL;

  2135.         u->output.buf->pos = u->output.buf->start;
  2136.         u->output.buf->last = u->output.buf->start;
  2137.     }

  2139.     u->output.buf = NULL;
  2140.     u->output.in = NULL;
  2141.     u->output.busy = NULL;

  2143.     /* reinit u->buffer */

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

  2147. #if (NGX_HTTP_CACHE)

  2149.     if (r->cache) {
  2150.         u->buffer.pos += r->cache->header_start;
  2151.     }

  2153. #endif

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

  2157.     return NGX_OK;
  2158. }


  2161. static void
  2162. ‌ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u,
  2163.     ngx_uint_t do_write)
  2164. {
  2165.     ngx_int_t          rc;
  2166.     ngx_connection_t  *c;

  2168.     c = u->peer.connection;

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

  2173.     if (u->state->connect_time == (ngx_msec_t) -1) {
  2174.         u->state->connect_time = ngx_current_msec - u->start_time;
  2175.     }

  2177.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2178.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2179.         return;
  2180.     }

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

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

  2186.     if (rc == NGX_ERROR) {
  2187.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2188.         return;
  2189.     }

  2191.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2192.         ngx_http_upstream_finalize_request(r, u, rc);
  2193.         return;
  2194.     }

  2196.     if (rc == NGX_AGAIN) {
  2197.         if (!c->write->ready || u->request_body_blocked) {
  2198.             ngx_add_timer(c->write, u->conf->send_timeout);

  2200.         } else if (c->write->timer_set) {
  2201.             ngx_del_timer(c->write);
  2202.         }

  2204.         if (ngx_handle_write_event(c->write, u->conf->send_lowat) != NGX_OK) {
  2205.             ngx_http_upstream_finalize_request(r, u,
  2206.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2207.             return;
  2208.         }

  2210.         if (c->write->ready && c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2211.             if (ngx_tcp_push(c->fd) == -1) {
  2212.                 ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2213.                               ngx_tcp_push_n " failed");
  2214.                 ngx_http_upstream_finalize_request(r, u,
  2215.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2216.                 return;
  2217.             }

  2219.             c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2220.         }

  2222.         if (c->read->ready) {
  2223.             ngx_post_event(c->read, &ngx_posted_events);
  2224.         }

  2226.         return;
  2227.     }

  2229.     /* rc == NGX_OK */

  2231.     if (c->write->timer_set) {
  2232.         ngx_del_timer(c->write);
  2233.     }

  2235.     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
  2236.         if (ngx_tcp_push(c->fd) == -1) {
  2237.             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
  2238.                           ngx_tcp_push_n " failed");
  2239.             ngx_http_upstream_finalize_request(r, u,
  2240.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2241.             return;
  2242.         }

  2244.         c->tcp_nopush = NGX_TCP_NOPUSH_UNSET;
  2245.     }

  2247.     if (!u->conf->preserve_output) {
  2248.         u->write_event_handler = ngx_http_upstream_dummy_handler;
  2249.     }

  2251.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2252.         ngx_http_upstream_finalize_request(r, u,
  2253.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2254.         return;
  2255.     }

  2257.     if (!u->request_body_sent) {
  2258.         u->request_body_sent = 1;

  2260.         if (u->header_sent) {
  2261.             return;
  2262.         }

  2264.         if (u->conf->ignore_input) {
  2265.             ngx_http_upstream_process_header(r, u);
  2266.             return;
  2267.         }

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

  2271.         if (c->read->ready) {
  2272.             ngx_http_upstream_process_header(r, u);
  2273.             return;
  2274.         }
  2275.     }
  2276. }


  2279. static ngx_int_t
  2280. ‌ngx_http_upstream_send_request_body(ngx_http_request_t *r,
  2281.     ngx_http_upstream_t *u, ngx_uint_t do_write)
  2282. {
  2283.     ngx_int_t                  rc;
  2284.     ngx_chain_t               *out, *cl, *ln;
  2285.     ngx_connection_t          *c;
  2286.     ngx_http_core_loc_conf_t  *clcf;

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

  2291.     if (!r->request_body_no_buffering) {

  2293.         /* buffered request body */

  2295.         if (!u->request_sent) {
  2296.             u->request_sent = 1;
  2297.             out = u->request_bufs;

  2299.         } else {
  2300.             out = NULL;
  2301.         }

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

  2305.         if (rc == NGX_AGAIN) {
  2306.             u->request_body_blocked = 1;

  2308.         } else {
  2309.             u->request_body_blocked = 0;
  2310.         }

  2312.         return rc;
  2313.     }

  2315.     if (!u->request_sent) {
  2316.         u->request_sent = 1;
  2317.         out = u->request_bufs;

  2319.         if (r->request_body->bufs) {
  2320.             for (cl = out; cl->next; cl = cl->next) { /* void */ }
  2321.             cl->next = r->request_body->bufs;
  2322.             r->request_body->bufs = NULL;
  2323.         }

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

  2328.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  2329.             return NGX_ERROR;
  2330.         }

  2332.         r->read_event_handler = ngx_http_upstream_read_request_handler;

  2334.     } else {
  2335.         out = NULL;
  2336.     }

  2338.     for ( ;; ) {

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

  2343.             if (rc == NGX_ERROR) {
  2344.                 return NGX_ERROR;
  2345.             }

  2347.             while (out) {
  2348.                 ln = out;
  2349.                 out = out->next;
  2350.                 ngx_free_chain(r->pool, ln);
  2351.             }

  2353.             if (rc == NGX_AGAIN) {
  2354.                 u->request_body_blocked = 1;

  2356.             } else {
  2357.                 u->request_body_blocked = 0;
  2358.             }

  2360.             if (rc == NGX_OK && !r->reading_body) {
  2361.                 break;
  2362.             }
  2363.         }

  2365.         if (r->reading_body) {
  2366.             /* read client request body */

  2368.             rc = ngx_http_read_unbuffered_request_body(r);

  2370.             if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  2371.                 return rc;
  2372.             }

  2374.             out = r->request_body->bufs;
  2375.             r->request_body->bufs = NULL;
  2376.         }

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

  2380.         if (out == NULL) {
  2381.             rc = NGX_AGAIN;
  2382.             break;
  2383.         }

  2385.         do_write = 1;
  2386.     }

  2388.     if (!r->reading_body) {
  2389.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2390.             r->read_event_handler =
  2391.                                   ngx_http_upstream_rd_check_broken_connection;
  2392.         }
  2393.     }

  2395.     return rc;
  2396. }


  2399. static void
  2400. ‌ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
  2401.     ngx_http_upstream_t *u)
  2402. {
  2403.     ngx_connection_t  *c;

  2405.     c = u->peer.connection;

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

  2410.     if (c->write->timedout) {
  2411.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2412.         return;
  2413.     }

  2415. #if (NGX_HTTP_SSL)

  2417.     if (u->ssl && c->ssl == NULL) {
  2418.         ngx_http_upstream_ssl_init_connection(r, u, c);
  2419.         return;
  2420.     }

  2422. #endif

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

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

  2429.         return;
  2430.     }

  2432.     ngx_http_upstream_send_request(r, u, 1);
  2433. }


  2436. static void
  2437. ‌ngx_http_upstream_read_request_handler(ngx_http_request_t *r)
  2438. {
  2439.     ngx_connection_t     *c;
  2440.     ngx_http_upstream_t  *u;

  2442.     c = r->connection;
  2443.     u = r->upstream;

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

  2448.     if (c->read->timedout) {
  2449.         c->timedout = 1;
  2450.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  2451.         return;
  2452.     }

  2454.     ngx_http_upstream_send_request(r, u, 0);
  2455. }


  2458. static void
  2459. ‌ngx_http_upstream_process_header(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2460. {
  2461.     ssize_t            n;
  2462.     ngx_int_t          rc;
  2463.     ngx_connection_t  *c;

  2465.     c = u->peer.connection;

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

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

  2472.     if (c->read->timedout) {
  2473.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_TIMEOUT);
  2474.         return;
  2475.     }

  2477.     if (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {
  2478.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2479.         return;
  2480.     }

  2482.     if (u->buffer.start == NULL) {
  2483.         u->buffer.start = ngx_palloc(r->pool, u->conf->buffer_size);
  2484.         if (u->buffer.start == NULL) {
  2485.             ngx_http_upstream_finalize_request(r, u,
  2486.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2487.             return;
  2488.         }

  2490.         u->buffer.pos = u->buffer.start;
  2491.         u->buffer.last = u->buffer.start;
  2492.         u->buffer.end = u->buffer.start + u->conf->buffer_size;
  2493.         u->buffer.temporary = 1;

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

  2497.         if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2498.                           sizeof(ngx_table_elt_t))
  2499.             != NGX_OK)
  2500.         {
  2501.             ngx_http_upstream_finalize_request(r, u,
  2502.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2503.             return;
  2504.         }

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

  2515. #if (NGX_HTTP_CACHE)

  2517.         if (r->cache) {
  2518.             u->buffer.pos += r->cache->header_start;
  2519.             u->buffer.last = u->buffer.pos;
  2520.         }
  2521. #endif
  2522.     }

  2524.     if (u->conf->ignore_input) {
  2525.         rc = u->process_header(r);
  2526.         goto done;
  2527.     }

  2529.     for ( ;; ) {

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

  2533.         if (n == NGX_AGAIN) {
  2534. #if 0
  2535.             ngx_add_timer(rev, u->read_timeout);
  2536. #endif

  2538.             if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  2539.                 ngx_http_upstream_finalize_request(r, u,
  2540.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2541.                 return;
  2542.             }

  2544.             return;
  2545.         }

  2547.         if (n == 0) {
  2548.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2549.                           "upstream prematurely closed connection");
  2550.         }

  2552.         if (n == NGX_ERROR || n == 0) {
  2553.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2554.             return;
  2555.         }

  2557. #if (NGX_HTTP_SSL)
  2558.         if (u->ssl && c->ssl == NULL) {
  2559.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  2560.                           "upstream prematurely sent response");
  2561.             ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);
  2562.             return;
  2563.         }
  2564. #endif

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

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

  2570. #if 0
  2571.         u->valid_header_in = 0;

  2573.         u->peer.cached = 0;
  2574. #endif

  2576.         u->response_received = 1;

  2578. again:

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

  2582.         if (rc == NGX_AGAIN) {

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

  2588.                 ngx_http_upstream_next(r, u,
  2589.                                        NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2590.                 return;
  2591.             }

  2593.             continue;
  2594.         }

  2596.         if (rc == NGX_HTTP_UPSTREAM_EARLY_HINTS) {
  2597.             rc = ngx_http_upstream_process_early_hints(r, u);

  2599.             if (rc == NGX_OK) {
  2600.                 goto again;
  2601.             }
  2602.         }

  2604.         break;
  2605.     }

  2607. done:

  2609.     if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2610.         ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_INVALID_HEADER);
  2611.         return;
  2612.     }

  2614.     if (rc == NGX_ERROR) {
  2615.         ngx_http_upstream_finalize_request(r, u,
  2616.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2617.         return;
  2618.     }

  2620.     /* rc == NGX_OK */

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

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

  2626.         if (ngx_http_upstream_test_next(r, u) == NGX_OK) {
  2627.             return;
  2628.         }

  2630.         if (ngx_http_upstream_intercept_errors(r, u) == NGX_OK) {
  2631.             return;
  2632.         }
  2633.     }

  2635.     if (u->peer.notify) {
  2636.         u->peer.notify(&u->peer, u->peer.data, NGX_HTTP_UPSTREAM_NOTIFY_HEADER);
  2637.     }

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

  2643.     ngx_http_upstream_send_response(r, u);
  2644. }


  2647. static ngx_int_t
  2648. ‌ngx_http_upstream_process_early_hints(ngx_http_request_t *r,
  2649.     ngx_http_upstream_t *u)
  2650. {
  2651.     u_char            *p;
  2652.     ngx_uint_t         i;
  2653.     ngx_list_part_t   *part;
  2654.     ngx_table_elt_t   *h, *ho;
  2655.     ngx_connection_t  *c;

  2657.     c = r->connection;

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

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

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

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

  2667.             part = &u->headers_in.headers.part;
  2668.             h = part->elts;

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

  2672.                 if (i >= part->nelts) {
  2673.                     if (part->next == NULL) {
  2674.                         break;
  2675.                     }

  2677.                     part = part->next;
  2678.                     h = part->elts;
  2679.                     i = 0;
  2680.                 }

  2682.                 if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  2683.                                   h[i].lowcase_key, h[i].key.len))
  2684.                 {
  2685.                     continue;
  2686.                 }

  2688.                 ho = ngx_list_push(&r->headers_out.headers);
  2689.                 if (ho == NULL) {
  2690.                     return NGX_ERROR;
  2691.                 }

  2693.                 *ho = h[i];
  2694.             }

  2696.             if (ngx_http_send_early_hints(r) == NGX_ERROR) {
  2697.                 return NGX_ERROR;
  2698.             }

  2700.             if (c->buffered) {
  2701.                 if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2702.                     return NGX_ERROR;
  2703.                 }

  2705.                 r->write_event_handler = ngx_http_upstream_early_hints_writer;
  2706.             }

  2708.         } else {
  2709.             ngx_log_error(NGX_LOG_INFO, c->log, 0,
  2710.                           "upstream sent too big early hints");
  2711.         }
  2712.     }

  2714.     ngx_http_clean_header(r);

  2716.     ngx_memzero(&u->headers_in, sizeof(ngx_http_upstream_headers_in_t));
  2717.     u->headers_in.content_length_n = -1;
  2718.     u->headers_in.last_modified_time = -1;

  2720.     if (ngx_list_init(&u->headers_in.headers, r->pool, 8,
  2721.                       sizeof(ngx_table_elt_t))
  2722.         != NGX_OK)
  2723.     {
  2724.         return NGX_ERROR;
  2725.     }

  2727.     if (ngx_list_init(&u->headers_in.trailers, r->pool, 2,
  2728.                       sizeof(ngx_table_elt_t))
  2729.         != NGX_OK)
  2730.     {
  2731.         return NGX_ERROR;
  2732.     }

  2734.     p = u->buffer.pos;

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

  2738. #if (NGX_HTTP_CACHE)

  2740.     if (r->cache) {
  2741.         u->buffer.pos += r->cache->header_start;
  2742.     }

  2744. #endif

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

  2748.     return NGX_OK;
  2749. }


  2752. static void
  2753. ‌ngx_http_upstream_early_hints_writer(ngx_http_request_t *r)
  2754. {
  2755.     ngx_connection_t     *c;
  2756.     ngx_http_upstream_t  *u;

  2758.     c = r->connection;
  2759.     u = r->upstream;

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

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

  2766.     if (ngx_http_write_filter(r, NULL) == NGX_ERROR) {
  2767.         ngx_http_upstream_finalize_request(r, u,
  2768.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2769.         return;
  2770.     }

  2772.     if (!c->buffered) {
  2773.         if (!u->store && !r->post_action && !u->conf->ignore_client_abort) {
  2774.             r->write_event_handler =
  2775.                                   ngx_http_upstream_wr_check_broken_connection;

  2777.         } else {
  2778.             r->write_event_handler = ngx_http_request_empty_handler;
  2779.         }
  2780.     }

  2782.     if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  2783.         ngx_http_upstream_finalize_request(r, u,
  2784.                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
  2785.     }
  2786. }


  2789. static ngx_int_t
  2790. ‌ngx_http_upstream_test_next(ngx_http_request_t *r, ngx_http_upstream_t *u)
  2791. {
  2792.     ngx_msec_t                 timeout;
  2793.     ngx_uint_t                 status, mask;
  2794.     ngx_http_upstream_next_t  *un;

  2796.     status = u->headers_in.status_n;

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

  2800.         if (status != un->status) {
  2801.             continue;
  2802.         }

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

  2806.         if (u->request_sent
  2807.             && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  2808.         {
  2809.             mask = un->mask | NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;

  2811.         } else {
  2812.             mask = un->mask;
  2813.         }

  2815.         if (u->peer.tries > 1
  2816.             && ((u->conf->next_upstream & mask) == mask)
  2817.             && !(u->request_sent && r->request_body_no_buffering)
  2818.             && !(timeout && ngx_current_msec - u->peer.start_time >= timeout))
  2819.         {
  2820.             ngx_http_upstream_next(r, u, un->mask);
  2821.             return NGX_OK;
  2822.         }

  2824. #if (NGX_HTTP_CACHE)

  2826.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2827.             && (u->conf->cache_use_stale & un->mask))
  2828.         {
  2829.             ngx_int_t  rc;

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

  2833.             if (rc != NGX_OK) {
  2834.                 ngx_http_upstream_finalize_request(r, u, rc);
  2835.                 return NGX_OK;
  2836.             }

  2838.             u->cache_status = NGX_HTTP_CACHE_STALE;
  2839.             rc = ngx_http_upstream_cache_send(r, u);

  2841.             if (rc == NGX_DONE) {
  2842.                 return NGX_OK;
  2843.             }

  2845.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2846.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2847.             }

  2849.             ngx_http_upstream_finalize_request(r, u, rc);
  2850.             return NGX_OK;
  2851.         }

  2853. #endif

  2855.         break;
  2856.     }

  2858. #if (NGX_HTTP_CACHE)

  2860.     if (status == NGX_HTTP_NOT_MODIFIED
  2861.         && u->cache_status == NGX_HTTP_CACHE_EXPIRED
  2862.         && u->conf->cache_revalidate)
  2863.     {
  2864.         time_t     now, valid, updating, error;
  2865.         ngx_int_t  rc;

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

  2870.         now = ngx_time();

  2872.         valid = r->cache->valid_sec;
  2873.         updating = r->cache->updating_sec;
  2874.         error = r->cache->error_sec;

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

  2878.         if (rc != NGX_OK) {
  2879.             ngx_http_upstream_finalize_request(r, u, rc);
  2880.             return NGX_OK;
  2881.         }

  2883.         u->cache_status = NGX_HTTP_CACHE_REVALIDATED;
  2884.         rc = ngx_http_upstream_cache_send(r, u);

  2886.         if (rc == NGX_DONE) {
  2887.             return NGX_OK;
  2888.         }

  2890.         if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  2891.             rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  2892.         }

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

  2900.         if (valid == 0) {
  2901.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  2902.                                               u->headers_in.status_n);
  2903.             if (valid) {
  2904.                 valid = now + valid;
  2905.             }
  2906.         }

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

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

  2915.             ngx_http_file_cache_update_header(r);
  2916.         }

  2918.         ngx_http_upstream_finalize_request(r, u, rc);
  2919.         return NGX_OK;
  2920.     }

  2922. #endif

  2924.     return NGX_DECLINED;
  2925. }


  2928. static ngx_int_t
  2929. ‌ngx_http_upstream_intercept_errors(ngx_http_request_t *r,
  2930.     ngx_http_upstream_t *u)
  2931. {
  2932.     ngx_int_t                  status;
  2933.     ngx_uint_t                 i;
  2934.     ngx_table_elt_t           *h, *ho, **ph;
  2935.     ngx_http_err_page_t       *err_page;
  2936.     ngx_http_core_loc_conf_t  *clcf;

  2938.     status = u->headers_in.status_n;

  2940.     if (status == NGX_HTTP_NOT_FOUND && u->conf->intercept_404) {
  2941.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_NOT_FOUND);
  2942.         return NGX_OK;
  2943.     }

  2945.     if (!u->conf->intercept_errors) {
  2946.         return NGX_DECLINED;
  2947.     }

  2949.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  2951.     if (clcf->error_pages == NULL) {
  2952.         return NGX_DECLINED;
  2953.     }

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

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

  2960.             if (status == NGX_HTTP_UNAUTHORIZED
  2961.                 && u->headers_in.www_authenticate)
  2962.             {
  2963.                 h = u->headers_in.www_authenticate;
  2964.                 ph = &r->headers_out.www_authenticate;

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

  2969.                     if (ho == NULL) {
  2970.                         ngx_http_upstream_finalize_request(r, u,
  2971.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  2972.                         return NGX_OK;
  2973.                     }

  2975.                     *ho = *h;
  2976.                     ho->next = NULL;

  2978.                     *ph = ho;
  2979.                     ph = &ho->next;

  2981.                     h = h->next;
  2982.                 }
  2983.             }

  2985. #if (NGX_HTTP_CACHE)

  2987.             if (r->cache) {

  2989.                 if (u->headers_in.no_cache || u->headers_in.expired) {
  2990.                     u->cacheable = 0;
  2991.                 }

  2993.                 if (u->cacheable) {
  2994.                     time_t  valid;

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

  2998.                     if (valid == 0) {
  2999.                         valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  3000.                                                           status);
  3001.                         if (valid) {
  3002.                             r->cache->valid_sec = ngx_time() + valid;
  3003.                         }
  3004.                     }

  3006.                     if (valid) {
  3007.                         r->cache->error = status;
  3008.                     }
  3009.                 }

  3011.                 ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3012.             }
  3013. #endif
  3014.             ngx_http_upstream_finalize_request(r, u, status);

  3016.             return NGX_OK;
  3017.         }
  3018.     }

  3020.     return NGX_DECLINED;
  3021. }


  3024. static ngx_int_t
  3025. ‌ngx_http_upstream_test_connect(ngx_connection_t *c)
  3026. {
  3027.     int        err;
  3028.     socklen_t  len;

  3030. #if (NGX_HAVE_KQUEUE)

  3032.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
  3033.         if (c->write->pending_eof || c->read->pending_eof) {
  3034.             if (c->write->pending_eof) {
  3035.                 err = c->write->kq_errno;

  3037.             } else {
  3038.                 err = c->read->kq_errno;
  3039.             }

  3041.             c->log->action = "connecting to upstream";
  3042.             (void) ngx_connection_error(c, err,
  3043.                                     "kevent() reported that connect() failed");
  3044.             return NGX_ERROR;
  3045.         }

  3047.     } else
  3048. #endif
  3049.     {
  3050.         err = 0;
  3051.         len = sizeof(int);

  3053.         /*
  3054.          * BSDs and Linux return 0 and set a pending error in err
  3055.          * Solaris returns -1 and sets errno
  3056.          */

  3058.         if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len)
  3059.             == -1)
  3060.         {
  3061.             err = ngx_socket_errno;
  3062.         }

  3064.         if (err) {
  3065.             c->log->action = "connecting to upstream";
  3066.             (void) ngx_connection_error(c, err, "connect() failed");
  3067.             return NGX_ERROR;
  3068.         }
  3069.     }

  3071.     return NGX_OK;
  3072. }


  3075. static ngx_int_t
  3076. ‌ngx_http_upstream_process_headers(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3077. {
  3078.     ngx_str_t                       uri, args;
  3079.     ngx_uint_t                      i, flags;
  3080.     ngx_list_part_t                *part;
  3081.     ngx_table_elt_t                *h;
  3082.     ngx_http_upstream_header_t     *hh;
  3083.     ngx_http_upstream_main_conf_t  *umcf;

  3085.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  3087.     if (u->headers_in.no_cache || u->headers_in.expired) {
  3088.         u->cacheable = 0;
  3089.     }

  3091.     if (u->headers_in.x_accel_redirect
  3092.         && !(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_REDIRECT))
  3093.     {
  3094.         ngx_http_upstream_finalize_request(r, u, NGX_DECLINED);

  3096.         part = &u->headers_in.headers.part;
  3097.         h = part->elts;

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

  3101.             if (i >= part->nelts) {
  3102.                 if (part->next == NULL) {
  3103.                     break;
  3104.                 }

  3106.                 part = part->next;
  3107.                 h = part->elts;
  3108.                 i = 0;
  3109.             }

  3111.             if (h[i].hash == 0) {
  3112.                 continue;
  3113.             }

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

  3118.             if (hh && hh->redirect) {
  3119.                 if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  3120.                     ngx_http_finalize_request(r,
  3121.                                               NGX_HTTP_INTERNAL_SERVER_ERROR);
  3122.                     return NGX_DONE;
  3123.                 }
  3124.             }
  3125.         }

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

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

  3132.         } else {
  3133.             ngx_str_null(&args);
  3134.             flags = NGX_HTTP_LOG_UNSAFE;

  3136.             if (ngx_http_parse_unsafe_uri(r, &uri, &args, &flags) != NGX_OK) {
  3137.                 ngx_http_finalize_request(r, NGX_HTTP_NOT_FOUND);
  3138.                 return NGX_DONE;
  3139.             }

  3141.             if (r->method != NGX_HTTP_HEAD) {
  3142.                 r->method = NGX_HTTP_GET;
  3143.                 r->method_name = ngx_http_core_get_method;
  3144.             }

  3146.             ngx_http_internal_redirect(r, &uri, &args);
  3147.         }

  3149.         ngx_http_finalize_request(r, NGX_DONE);
  3150.         return NGX_DONE;
  3151.     }

  3153.     part = &u->headers_in.headers.part;
  3154.     h = part->elts;

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

  3158.         if (i >= part->nelts) {
  3159.             if (part->next == NULL) {
  3160.                 break;
  3161.             }

  3163.             part = part->next;
  3164.             h = part->elts;
  3165.             i = 0;
  3166.         }

  3168.         if (h[i].hash == 0) {
  3169.             continue;
  3170.         }

  3172.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3173.                           h[i].lowcase_key, h[i].key.len))
  3174.         {
  3175.             continue;
  3176.         }

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

  3181.         if (hh) {
  3182.             if (hh->copy_handler(r, &h[i], hh->conf) != NGX_OK) {
  3183.                 ngx_http_upstream_finalize_request(r, u,
  3184.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  3185.                 return NGX_DONE;
  3186.             }

  3188.             continue;
  3189.         }

  3191.         if (ngx_http_upstream_copy_header_line(r, &h[i], 0) != NGX_OK) {
  3192.             ngx_http_upstream_finalize_request(r, u,
  3193.                                                NGX_HTTP_INTERNAL_SERVER_ERROR);
  3194.             return NGX_DONE;
  3195.         }
  3196.     }

  3198.     if (r->headers_out.server && r->headers_out.server->value.data == NULL) {
  3199.         r->headers_out.server->hash = 0;
  3200.     }

  3202.     if (r->headers_out.date && r->headers_out.date->value.data == NULL) {
  3203.         r->headers_out.date->hash = 0;
  3204.     }

  3206.     r->headers_out.status = u->headers_in.status_n;
  3207.     r->headers_out.status_line = u->headers_in.status_line;

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

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

  3213.     if (u->conf->force_ranges) {
  3214.         r->allow_ranges = 1;
  3215.         r->single_range = 1;

  3217. #if (NGX_HTTP_CACHE)
  3218.         if (r->cached) {
  3219.             r->single_range = 0;
  3220.         }
  3221. #endif
  3222.     }

  3224.     u->length = -1;

  3226.     return NGX_OK;
  3227. }


  3230. static ngx_int_t
  3231. ‌ngx_http_upstream_process_trailers(ngx_http_request_t *r,
  3232.     ngx_http_upstream_t *u)
  3233. {
  3234.     ngx_uint_t        i;
  3235.     ngx_list_part_t  *part;
  3236.     ngx_table_elt_t  *h, *ho;

  3238.     if (!u->conf->pass_trailers) {
  3239.         return NGX_OK;
  3240.     }

  3242.     part = &u->headers_in.trailers.part;
  3243.     h = part->elts;

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

  3247.         if (i >= part->nelts) {
  3248.             if (part->next == NULL) {
  3249.                 break;
  3250.             }

  3252.             part = part->next;
  3253.             h = part->elts;
  3254.             i = 0;
  3255.         }

  3257.         if (ngx_hash_find(&u->conf->hide_headers_hash, h[i].hash,
  3258.                           h[i].lowcase_key, h[i].key.len))
  3259.         {
  3260.             continue;
  3261.         }

  3263.         ho = ngx_list_push(&r->headers_out.trailers);
  3264.         if (ho == NULL) {
  3265.             return NGX_ERROR;
  3266.         }

  3268.         *ho = h[i];
  3269.     }

  3271.     return NGX_OK;
  3272. }


  3275. static void
  3276. ‌ngx_http_upstream_send_response(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3277. {
  3278.     ssize_t                    n;
  3279.     ngx_int_t                  rc;
  3280.     ngx_event_pipe_t          *p;
  3281.     ngx_connection_t          *c;
  3282.     ngx_http_core_loc_conf_t  *clcf;

  3284.     rc = ngx_http_send_header(r);

  3286.     if (rc == NGX_ERROR || rc > NGX_OK || r->post_action) {
  3287.         ngx_http_upstream_finalize_request(r, u, rc);
  3288.         return;
  3289.     }

  3291.     u->header_sent = 1;

  3293.     if (u->upgrade) {

  3295. #if (NGX_HTTP_CACHE)

  3297.         if (r->cache) {
  3298.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3299.         }

  3301. #endif

  3303.         ngx_http_upstream_upgrade(r, u);
  3304.         return;
  3305.     }

  3307.     c = r->connection;

  3309.     if (r->header_only) {

  3311.         if (!u->buffering) {
  3312.             ngx_http_upstream_finalize_request(r, u, rc);
  3313.             return;
  3314.         }

  3316.         if (!u->cacheable && !u->store) {
  3317.             ngx_http_upstream_finalize_request(r, u, rc);
  3318.             return;
  3319.         }

  3321.         u->pipe->downstream_error = 1;
  3322.     }

  3324.     if (r->request_body && r->request_body->temp_file
  3325.         && r == r->main && !r->preserve_body
  3326.         && !u->conf->preserve_output)
  3327.     {
  3328.         ngx_pool_run_cleanup_file(r->pool, r->request_body->temp_file->file.fd);
  3329.         r->request_body->temp_file->file.fd = NGX_INVALID_FILE;
  3330.     }

  3332.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3334.     if (!u->buffering) {

  3336. #if (NGX_HTTP_CACHE)

  3338.         if (r->cache) {
  3339.             ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3340.         }

  3342. #endif

  3344.         if (u->input_filter == NULL) {
  3345.             u->input_filter_init = ngx_http_upstream_non_buffered_filter_init;
  3346.             u->input_filter = ngx_http_upstream_non_buffered_filter;
  3347.             u->input_filter_ctx = r;
  3348.         }

  3350.         u->read_event_handler = ngx_http_upstream_process_non_buffered_upstream;
  3351.         r->write_event_handler =
  3352.                              ngx_http_upstream_process_non_buffered_downstream;

  3354.         r->limit_rate = 0;
  3355.         r->limit_rate_set = 1;

  3357.         if (u->input_filter_init(u->input_filter_ctx) == NGX_ERROR) {
  3358.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3359.             return;
  3360.         }

  3362.         if (clcf->tcp_nodelay && ngx_tcp_nodelay(c) != NGX_OK) {
  3363.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3364.             return;
  3365.         }

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

  3369.         if (n) {
  3370.             u->buffer.last = u->buffer.pos;

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

  3374.             if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  3375.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3376.                 return;
  3377.             }

  3379.             ngx_http_upstream_process_non_buffered_downstream(r);

  3381.         } else {
  3382.             u->buffer.pos = u->buffer.start;
  3383.             u->buffer.last = u->buffer.start;

  3385.             if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3386.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3387.                 return;
  3388.             }

  3390.             ngx_http_upstream_process_non_buffered_upstream(r, u);
  3391.         }

  3393.         return;
  3394.     }

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

  3398. #if (NGX_HTTP_CACHE)

  3400.     if (r->cache && r->cache->file.fd != NGX_INVALID_FILE) {
  3401.         ngx_pool_run_cleanup_file(r->pool, r->cache->file.fd);
  3402.         r->cache->file.fd = NGX_INVALID_FILE;
  3403.     }

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

  3407.     case NGX_ERROR:
  3408.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3409.         return;

  3411.     case NGX_DECLINED:
  3412.         u->cacheable = 0;
  3413.         break;

  3415.     default: /* NGX_OK */

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

  3419.             /* create cache if previously bypassed */

  3421.             if (ngx_http_file_cache_create(r) != NGX_OK) {
  3422.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3423.                 return;
  3424.             }
  3425.         }

  3427.         break;
  3428.     }

  3430.     if (u->cacheable) {
  3431.         time_t  now, valid;

  3433.         now = ngx_time();

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

  3437.         if (valid == 0) {
  3438.             valid = ngx_http_file_cache_valid(u->conf->cache_valid,
  3439.                                               u->headers_in.status_n);
  3440.             if (valid) {
  3441.                 r->cache->valid_sec = now + valid;
  3442.             }
  3443.         }

  3445.         if (valid) {
  3446.             r->cache->date = now;
  3447.             r->cache->body_start = (u_short) (u->buffer.pos - u->buffer.start);

  3449.             if (u->headers_in.status_n == NGX_HTTP_OK
  3450.                 || u->headers_in.status_n == NGX_HTTP_PARTIAL_CONTENT)
  3451.             {
  3452.                 r->cache->last_modified = u->headers_in.last_modified_time;

  3454.                 if (u->headers_in.etag) {
  3455.                     r->cache->etag = u->headers_in.etag->value;

  3457.                 } else {
  3458.                     ngx_str_null(&r->cache->etag);
  3459.                 }

  3461.             } else {
  3462.                 r->cache->last_modified = -1;
  3463.                 ngx_str_null(&r->cache->etag);
  3464.             }

  3466.             if (ngx_http_file_cache_set_header(r, u->buffer.start) != NGX_OK) {
  3467.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3468.                 return;
  3469.             }

  3471.         } else {
  3472.             u->cacheable = 0;
  3473.         }
  3474.     }

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

  3479.     if (u->cacheable == 0 && r->cache) {
  3480.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  3481.     }

  3483.     if (r->header_only && !u->cacheable && !u->store) {
  3484.         ngx_http_upstream_finalize_request(r, u, 0);
  3485.         return;
  3486.     }

  3488. #endif

  3490.     p = u->pipe;

  3492.     p->output_filter = ngx_http_upstream_output_filter;
  3493.     p->output_ctx = r;
  3494.     p->tag = u->output.tag;
  3495.     p->bufs = u->conf->bufs;
  3496.     p->busy_size = u->conf->busy_buffers_size;
  3497.     p->upstream = u->peer.connection;
  3498.     p->downstream = c;
  3499.     p->pool = r->pool;
  3500.     p->log = c->log;
  3501.     p->limit_rate = ngx_http_complex_value_size(r, u->conf->limit_rate, 0);
  3502.     p->start_sec = ngx_time();

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

  3506.     p->temp_file = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  3507.     if (p->temp_file == NULL) {
  3508.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3509.         return;
  3510.     }

  3512.     p->temp_file->file.fd = NGX_INVALID_FILE;
  3513.     p->temp_file->file.log = c->log;
  3514.     p->temp_file->path = u->conf->temp_path;
  3515.     p->temp_file->pool = r->pool;

  3517.     if (p->cacheable) {
  3518.         p->temp_file->persistent = 1;

  3520. #if (NGX_HTTP_CACHE)
  3521.         if (r->cache && !r->cache->file_cache->use_temp_path) {
  3522.             p->temp_file->path = r->cache->file_cache->path;
  3523.             p->temp_file->file.name = r->cache->file.name;
  3524.         }
  3525. #endif

  3527.     } else {
  3528.         p->temp_file->log_level = NGX_LOG_WARN;
  3529.         p->temp_file->warn = "an upstream response is buffered "
  3530.                              "to a temporary file";
  3531.     }

  3533.     p->max_temp_file_size = u->conf->max_temp_file_size;
  3534.     p->temp_file_write_size = u->conf->temp_file_write_size;

  3536. #if (NGX_THREADS)
  3537.     if (clcf->aio == NGX_HTTP_AIO_THREADS && clcf->aio_write) {
  3538.         p->thread_handler = ngx_http_upstream_thread_handler;
  3539.         p->thread_ctx = r;
  3540.     }
  3541. #endif

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

  3549.     p->preread_bufs->buf = &u->buffer;
  3550.     p->preread_bufs->next = NULL;
  3551.     u->buffer.recycled = 1;

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

  3555.     if (u->cacheable) {

  3557.         p->buf_to_file = ngx_calloc_buf(r->pool);
  3558.         if (p->buf_to_file == NULL) {
  3559.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3560.             return;
  3561.         }

  3563.         p->buf_to_file->start = u->buffer.start;
  3564.         p->buf_to_file->pos = u->buffer.start;
  3565.         p->buf_to_file->last = u->buffer.pos;
  3566.         p->buf_to_file->temporary = 1;
  3567.     }

  3569.     if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
  3570.         /* the posted aio operation may corrupt a shadow buffer */
  3571.         p->single_buf = 1;
  3572.     }

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

  3577.     /*
  3578.      * event_pipe would do u->buffer.last += p->preread_size
  3579.      * as though these bytes were read
  3580.      */
  3581.     u->buffer.last = u->buffer.pos;

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

  3585.         /*
  3586.          * we need to disable the use of sendfile() if we use cyclic temp file
  3587.          * because the writing a new data may interfere with sendfile()
  3588.          * that uses the same kernel file pages (at least on FreeBSD)
  3589.          */

  3591.         p->cyclic_temp_file = 1;
  3592.         c->sendfile = 0;

  3594.     } else {
  3595.         p->cyclic_temp_file = 0;
  3596.     }

  3598.     p->read_timeout = u->conf->read_timeout;
  3599.     p->send_timeout = clcf->send_timeout;
  3600.     p->send_lowat = clcf->send_lowat;

  3602.     p->length = -1;

  3604.     if (u->input_filter_init
  3605.         && u->input_filter_init(p->input_ctx) != NGX_OK)
  3606.     {
  3607.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3608.         return;
  3609.     }

  3611.     u->read_event_handler = ngx_http_upstream_process_upstream;
  3612.     r->write_event_handler = ngx_http_upstream_process_downstream;

  3614.     ngx_http_upstream_process_upstream(r, u);
  3615. }


  3618. static void
  3619. ‌ngx_http_upstream_upgrade(ngx_http_request_t *r, ngx_http_upstream_t *u)
  3620. {
  3621.     ngx_connection_t          *c;
  3622.     ngx_http_core_loc_conf_t  *clcf;

  3624.     c = r->connection;
  3625.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  3629.     if (r != r->main) {
  3630.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  3631.                       "connection upgrade in subrequest");
  3632.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3633.         return;
  3634.     }

  3636.     r->keepalive = 0;
  3637.     c->log->action = "proxying upgraded connection";

  3639.     u->read_event_handler = ngx_http_upstream_upgraded_read_upstream;
  3640.     u->write_event_handler = ngx_http_upstream_upgraded_write_upstream;
  3641.     r->read_event_handler = ngx_http_upstream_upgraded_read_downstream;
  3642.     r->write_event_handler = ngx_http_upstream_upgraded_write_downstream;

  3644.     if (clcf->tcp_nodelay) {

  3646.         if (ngx_tcp_nodelay(c) != NGX_OK) {
  3647.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3648.             return;
  3649.         }

  3651.         if (ngx_tcp_nodelay(u->peer.connection) != NGX_OK) {
  3652.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3653.             return;
  3654.         }
  3655.     }

  3657.     if (ngx_http_send_special(r, NGX_HTTP_FLUSH) == NGX_ERROR) {
  3658.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3659.         return;
  3660.     }

  3662.     if (u->peer.connection->read->ready
  3663.         || u->buffer.pos != u->buffer.last)
  3664.     {
  3665.         ngx_post_event(c->read, &ngx_posted_events);
  3666.         ngx_http_upstream_process_upgraded(r, 1, 1);
  3667.         return;
  3668.     }

  3670.     ngx_http_upstream_process_upgraded(r, 0, 1);
  3671. }


  3674. static void
  3675. ‌ngx_http_upstream_upgraded_read_downstream(ngx_http_request_t *r)
  3676. {
  3677.     ngx_http_upstream_process_upgraded(r, 0, 0);
  3678. }


  3681. static void
  3682. ‌ngx_http_upstream_upgraded_write_downstream(ngx_http_request_t *r)
  3683. {
  3684.     ngx_http_upstream_process_upgraded(r, 1, 1);
  3685. }


  3688. static void
  3689. ‌ngx_http_upstream_upgraded_read_upstream(ngx_http_request_t *r,
  3690.     ngx_http_upstream_t *u)
  3691. {
  3692.     ngx_http_upstream_process_upgraded(r, 1, 0);
  3693. }


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


  3704. static void
  3705. ‌ngx_http_upstream_process_upgraded(ngx_http_request_t *r,
  3706.     ngx_uint_t from_upstream, ngx_uint_t do_write)
  3707. {
  3708.     size_t                     size;
  3709.     ssize_t                    n;
  3710.     ngx_buf_t                 *b;
  3711.     ngx_uint_t                 flags;
  3712.     ngx_connection_t          *c, *downstream, *upstream, *dst, *src;
  3713.     ngx_http_upstream_t       *u;
  3714.     ngx_http_core_loc_conf_t  *clcf;

  3716.     c = r->connection;
  3717.     u = r->upstream;

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

  3722.     downstream = c;
  3723.     upstream = u->peer.connection;

  3725.     if (downstream->write->timedout) {
  3726.         c->timedout = 1;
  3727.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3728.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3729.         return;
  3730.     }

  3732.     if (upstream->read->timedout || upstream->write->timedout) {
  3733.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3734.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3735.         return;
  3736.     }

  3738.     if (from_upstream) {
  3739.         src = upstream;
  3740.         dst = downstream;
  3741.         b = &u->buffer;

  3743.     } else {
  3744.         src = downstream;
  3745.         dst = upstream;
  3746.         b = &u->from_client;

  3748.         if (r->header_in->last > r->header_in->pos) {
  3749.             b = r->header_in;
  3750.             b->end = b->last;
  3751.             do_write = 1;
  3752.         }

  3754.         if (b->start == NULL) {
  3755.             b->start = ngx_palloc(r->pool, u->conf->buffer_size);
  3756.             if (b->start == NULL) {
  3757.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3758.                 return;
  3759.             }

  3761.             b->pos = b->start;
  3762.             b->last = b->start;
  3763.             b->end = b->start + u->conf->buffer_size;
  3764.             b->temporary = 1;
  3765.             b->tag = u->output.tag;
  3766.         }
  3767.     }

  3769.     for ( ;; ) {

  3771.         if (do_write) {

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

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

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

  3779.                 if (n == NGX_ERROR) {
  3780.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3781.                     return;
  3782.                 }

  3784.                 if (n > 0) {
  3785.                     b->pos += n;

  3787.                     if (b->pos == b->last) {
  3788.                         b->pos = b->start;
  3789.                         b->last = b->start;
  3790.                     }
  3791.                 }
  3792.             }
  3793.         }

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

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

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

  3801.             if (n == NGX_AGAIN || n == 0) {
  3802.                 break;
  3803.             }

  3805.             if (n > 0) {
  3806.                 do_write = 1;
  3807.                 b->last += n;

  3809.                 if (from_upstream) {
  3810.                     u->state->bytes_received += n;
  3811.                 }

  3813.                 continue;
  3814.             }

  3816.             if (n == NGX_ERROR) {
  3817.                 src->read->eof = 1;
  3818.             }
  3819.         }

  3821.         break;
  3822.     }

  3824.     if ((upstream->read->eof && u->buffer.pos == u->buffer.last)
  3825.         || (downstream->read->eof && u->from_client.pos == u->from_client.last)
  3826.         || (downstream->read->eof && upstream->read->eof))
  3827.     {
  3828.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
  3829.                        "http upstream upgraded done");
  3830.         ngx_http_upstream_finalize_request(r, u, 0);
  3831.         return;
  3832.     }

  3834.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  3836.     if (ngx_handle_write_event(upstream->write, u->conf->send_lowat)
  3837.         != NGX_OK)
  3838.     {
  3839.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3840.         return;
  3841.     }

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

  3846.     } else if (upstream->write->timer_set) {
  3847.         ngx_del_timer(upstream->write);
  3848.     }

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

  3853.     } else {
  3854.         flags = 0;
  3855.     }

  3857.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  3858.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3859.         return;
  3860.     }

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

  3865.     } else if (upstream->read->timer_set) {
  3866.         ngx_del_timer(upstream->read);
  3867.     }

  3869.     if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  3870.         != NGX_OK)
  3871.     {
  3872.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3873.         return;
  3874.     }

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

  3879.     } else {
  3880.         flags = 0;
  3881.     }

  3883.     if (ngx_handle_read_event(downstream->read, flags) != NGX_OK) {
  3884.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3885.         return;
  3886.     }

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

  3891.     } else if (downstream->write->timer_set) {
  3892.         ngx_del_timer(downstream->write);
  3893.     }
  3894. }


  3897. static void
  3898. ‌ngx_http_upstream_process_non_buffered_downstream(ngx_http_request_t *r)
  3899. {
  3900.     ngx_event_t          *wev;
  3901.     ngx_connection_t     *c;
  3902.     ngx_http_upstream_t  *u;

  3904.     c = r->connection;
  3905.     u = r->upstream;
  3906.     wev = c->write;

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

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

  3913.     if (wev->timedout) {
  3914.         c->timedout = 1;
  3915.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");
  3916.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_REQUEST_TIME_OUT);
  3917.         return;
  3918.     }

  3920.     ngx_http_upstream_process_non_buffered_request(r, 1);
  3921. }


  3924. static void
  3925. ‌ngx_http_upstream_process_non_buffered_upstream(ngx_http_request_t *r,
  3926.     ngx_http_upstream_t *u)
  3927. {
  3928.     ngx_connection_t  *c;

  3930.     c = u->peer.connection;

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

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

  3937.     if (c->read->timedout) {
  3938.         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
  3939.         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
  3940.         return;
  3941.     }

  3943.     ngx_http_upstream_process_non_buffered_request(r, 0);
  3944. }


  3947. static void
  3948. ‌ngx_http_upstream_process_non_buffered_request(ngx_http_request_t *r,
  3949.     ngx_uint_t do_write)
  3950. {
  3951.     size_t                     size;
  3952.     ssize_t                    n;
  3953.     ngx_buf_t                 *b;
  3954.     ngx_int_t                  rc;
  3955.     ngx_uint_t                 flags;
  3956.     ngx_connection_t          *downstream, *upstream;
  3957.     ngx_http_upstream_t       *u;
  3958.     ngx_http_core_loc_conf_t  *clcf;

  3960.     u = r->upstream;
  3961.     downstream = r->connection;
  3962.     upstream = u->peer.connection;

  3964.     b = &u->buffer;

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

  3968.     for ( ;; ) {

  3970.         if (do_write) {

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

  3975.                 if (rc == NGX_ERROR) {
  3976.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  3977.                     return;
  3978.                 }

  3980.                 ngx_chain_update_chains(r->pool, &u->free_bufs, &u->busy_bufs,
  3981.                                         &u->out_bufs, u->output.tag);
  3982.             }

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

  3986.                 if (u->length == 0
  3987.                     || (upstream->read->eof && u->length == -1))
  3988.                 {
  3989.                     ngx_http_upstream_finalize_request(r, u, 0);
  3990.                     return;
  3991.                 }

  3993.                 if (upstream->read->eof) {
  3994.                     ngx_log_error(NGX_LOG_ERR, upstream->log, 0,
  3995.                                   "upstream prematurely closed connection");

  3997.                     ngx_http_upstream_finalize_request(r, u,
  3998.                                                        NGX_HTTP_BAD_GATEWAY);
  3999.                     return;
  4000.                 }

  4002.                 if (upstream->read->error || u->error) {
  4003.                     ngx_http_upstream_finalize_request(r, u,
  4004.                                                        NGX_HTTP_BAD_GATEWAY);
  4005.                     return;
  4006.                 }

  4008.                 b->pos = b->start;
  4009.                 b->last = b->start;
  4010.             }
  4011.         }

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

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

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

  4019.             if (n == NGX_AGAIN) {
  4020.                 break;
  4021.             }

  4023.             if (n > 0) {
  4024.                 u->state->bytes_received += n;
  4025.                 u->state->response_length += n;

  4027.                 if (u->input_filter(u->input_filter_ctx, n) == NGX_ERROR) {
  4028.                     ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4029.                     return;
  4030.                 }
  4031.             }

  4033.             do_write = 1;

  4035.             continue;
  4036.         }

  4038.         break;
  4039.     }

  4041.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  4043.     if (downstream->data == r) {
  4044.         if (ngx_handle_write_event(downstream->write, clcf->send_lowat)
  4045.             != NGX_OK)
  4046.         {
  4047.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4048.             return;
  4049.         }
  4050.     }

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

  4055.     } else if (downstream->write->timer_set) {
  4056.         ngx_del_timer(downstream->write);
  4057.     }

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

  4062.     } else {
  4063.         flags = 0;
  4064.     }

  4066.     if (ngx_handle_read_event(upstream->read, flags) != NGX_OK) {
  4067.         ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4068.         return;
  4069.     }

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

  4074.     } else if (upstream->read->timer_set) {
  4075.         ngx_del_timer(upstream->read);
  4076.     }
  4077. }


  4080. ngx_int_t
  4081. ‌ngx_http_upstream_non_buffered_filter_init(void *data)
  4082. {
  4083.     return NGX_OK;
  4084. }


  4087. ngx_int_t
  4088. ‌ngx_http_upstream_non_buffered_filter(void *data, ssize_t bytes)
  4089. {
  4090.     ngx_http_request_t  *r = data;

  4092.     ngx_buf_t            *b;
  4093.     ngx_chain_t          *cl, **ll;
  4094.     ngx_http_upstream_t  *u;

  4096.     u = r->upstream;

  4098.     if (u->length == 0) {
  4099.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4100.                       "upstream sent more data than specified in "
  4101.                       "\"Content-Length\" header");
  4102.         return NGX_OK;
  4103.     }

  4105.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  4106.         ll = &cl->next;
  4107.     }

  4109.     cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  4110.     if (cl == NULL) {
  4111.         return NGX_ERROR;
  4112.     }

  4114.     *ll = cl;

  4116.     cl->buf->flush = 1;
  4117.     cl->buf->memory = 1;

  4119.     b = &u->buffer;

  4121.     cl->buf->pos = b->last;
  4122.     b->last += bytes;
  4123.     cl->buf->last = b->last;
  4124.     cl->buf->tag = u->output.tag;

  4126.     if (u->length == -1) {
  4127.         return NGX_OK;
  4128.     }

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

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

  4136.         cl->buf->last = cl->buf->pos + u->length;
  4137.         u->length = 0;

  4139.         return NGX_OK;
  4140.     }

  4142.     u->length -= bytes;

  4144.     return NGX_OK;
  4145. }


  4148. #if (NGX_THREADS)

  4150. static ngx_int_t
  4151. ‌ngx_http_upstream_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
  4152. {
  4153.     ngx_str_t                  name;
  4154.     ngx_event_pipe_t          *p;
  4155.     ngx_connection_t          *c;
  4156.     ngx_thread_pool_t         *tp;
  4157.     ngx_http_request_t        *r;
  4158.     ngx_http_core_loc_conf_t  *clcf;

  4160.     r = file->thread_ctx;
  4161.     p = r->upstream->pipe;

  4163.     if (r->aio) {
  4164.         /*
  4165.          * tolerate sendfile() calls if another operation is already
  4166.          * running; this can happen due to subrequests, multiple calls
  4167.          * of the next body filter from a filter, or in HTTP/2 due to
  4168.          * a write event on the main connection
  4169.          */

  4171.         c = r->connection;

  4173. #if (NGX_HTTP_V2)
  4174.         if (r->stream) {
  4175.             c = r->stream->connection->connection;
  4176.         }
  4177. #endif

  4179.         if (task == c->sendfile_task) {
  4180.             return NGX_OK;
  4181.         }
  4182.     }

  4184.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  4185.     tp = clcf->thread_pool;

  4187.     if (tp == NULL) {
  4188.         if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
  4189.             != NGX_OK)
  4190.         {
  4191.             return NGX_ERROR;
  4192.         }

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

  4196.         if (tp == NULL) {
  4197.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4198.                           "thread pool \"%V\" not found", &name);
  4199.             return NGX_ERROR;
  4200.         }
  4201.     }

  4203.     task->event.data = r;
  4204.     task->event.handler = ngx_http_upstream_thread_event_handler;

  4206.     if (ngx_thread_task_post(tp, task) != NGX_OK) {
  4207.         return NGX_ERROR;
  4208.     }

  4210.     r->main->blocked++;
  4211.     r->aio = 1;
  4212.     p->aio = 1;

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

  4216.     return NGX_OK;
  4217. }


  4220. static void
  4221. ‌ngx_http_upstream_thread_event_handler(ngx_event_t *ev)
  4222. {
  4223.     ngx_connection_t    *c;
  4224.     ngx_http_request_t  *r;

  4226.     r = ev->data;
  4227.     c = r->connection;

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

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

  4234.     if (ev->timedout) {
  4235.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  4236.                       "thread operation took too long");
  4237.         ev->timedout = 0;
  4238.         return;
  4239.     }

  4241.     if (ev->timer_set) {
  4242.         ngx_del_timer(ev);
  4243.     }

  4245.     r->main->blocked--;
  4246.     r->aio = 0;

  4248. #if (NGX_HTTP_V2)

  4250.     if (r->stream) {
  4251.         /*
  4252.          * for HTTP/2, update write event to make sure processing will
  4253.          * reach the main connection to handle sendfile() in threads
  4254.          */

  4256.         c->write->ready = 1;
  4257.         c->write->active = 0;
  4258.     }

  4260. #endif

  4262.     if (r->done || r->main->terminated) {
  4263.         /*
  4264.          * trigger connection event handler if the subrequest was
  4265.          * already finalized (this can happen if the handler is used
  4266.          * for sendfile() in threads), or if the request was terminated
  4267.          */

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

  4271.     } else {
  4272.         r->write_event_handler(r);
  4273.         ngx_http_run_posted_requests(c);
  4274.     }
  4275. }

  4277. #endif


  4280. static ngx_int_t
  4281. ‌ngx_http_upstream_output_filter(void *data, ngx_chain_t *chain)
  4282. {
  4283.     ngx_int_t            rc;
  4284.     ngx_event_pipe_t    *p;
  4285.     ngx_http_request_t  *r;

  4287.     r = data;
  4288.     p = r->upstream->pipe;

  4290.     rc = ngx_http_output_filter(r, chain);

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

  4294.     return rc;
  4295. }


  4298. static void
  4299. ‌ngx_http_upstream_process_downstream(ngx_http_request_t *r)
  4300. {
  4301.     ngx_event_t          *wev;
  4302.     ngx_connection_t     *c;
  4303.     ngx_event_pipe_t     *p;
  4304.     ngx_http_upstream_t  *u;

  4306.     c = r->connection;
  4307.     u = r->upstream;
  4308.     p = u->pipe;
  4309.     wev = c->write;

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

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

  4316. #if (NGX_THREADS)
  4317.     p->aio = r->aio;
  4318. #endif

  4320.     if (wev->timedout) {

  4322.         p->downstream_error = 1;
  4323.         c->timedout = 1;
  4324.         ngx_connection_error(c, NGX_ETIMEDOUT, "client timed out");

  4326.     } else {

  4328.         if (wev->delayed) {

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

  4333.             if (ngx_handle_write_event(wev, p->send_lowat) != NGX_OK) {
  4334.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4335.             }

  4337.             return;
  4338.         }

  4340.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4341.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4342.             return;
  4343.         }
  4344.     }

  4346.     ngx_http_upstream_process_request(r, u);
  4347. }


  4350. static void
  4351. ‌ngx_http_upstream_process_upstream(ngx_http_request_t *r,
  4352.     ngx_http_upstream_t *u)
  4353. {
  4354.     ngx_event_t       *rev;
  4355.     ngx_event_pipe_t  *p;
  4356.     ngx_connection_t  *c;

  4358.     c = u->peer.connection;
  4359.     p = u->pipe;
  4360.     rev = c->read;

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

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

  4367.     if (rev->timedout) {

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

  4372.     } else {

  4374.         if (rev->delayed) {

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

  4379.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  4380.                 ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4381.             }

  4383.             return;
  4384.         }

  4386.         if (ngx_event_pipe(p, 0) == NGX_ABORT) {
  4387.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4388.             return;
  4389.         }
  4390.     }

  4392.     ngx_http_upstream_process_request(r, u);
  4393. }


  4396. static void
  4397. ‌ngx_http_upstream_process_request(ngx_http_request_t *r,
  4398.     ngx_http_upstream_t *u)
  4399. {
  4400.     ngx_temp_file_t   *tf;
  4401.     ngx_event_pipe_t  *p;

  4403.     p = u->pipe;

  4405. #if (NGX_THREADS)

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

  4409.         /*
  4410.          * make sure to call ngx_event_pipe()
  4411.          * if there is an incomplete aio write
  4412.          */

  4414.         if (ngx_event_pipe(p, 1) == NGX_ABORT) {
  4415.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4416.             return;
  4417.         }
  4418.     }

  4420.     if (p->writing) {
  4421.         return;
  4422.     }

  4424. #endif

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

  4428.         if (u->store) {

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

  4432.                 tf = p->temp_file;

  4434.                 if (u->headers_in.status_n == NGX_HTTP_OK
  4435.                     && (p->upstream_done || p->length == -1)
  4436.                     && (u->headers_in.content_length_n == -1
  4437.                         || u->headers_in.content_length_n == tf->offset))
  4438.                 {
  4439.                     ngx_http_upstream_store(r, u);
  4440.                 }
  4441.             }
  4442.         }

  4444. #if (NGX_HTTP_CACHE)

  4446.         if (u->cacheable) {

  4448.             if (p->upstream_done) {
  4449.                 ngx_http_file_cache_update(r, p->temp_file);

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

  4453.                 tf = p->temp_file;

  4455.                 if (p->length == -1
  4456.                     && (u->headers_in.content_length_n == -1
  4457.                         || u->headers_in.content_length_n
  4458.                            == tf->offset - (off_t) r->cache->body_start))
  4459.                 {
  4460.                     ngx_http_file_cache_update(r, tf);

  4462.                 } else {
  4463.                     ngx_http_file_cache_free(r->cache, tf);
  4464.                 }

  4466.             } else if (p->upstream_error) {
  4467.                 ngx_http_file_cache_free(r->cache, p->temp_file);
  4468.             }
  4469.         }

  4471. #endif

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

  4477.             if (p->upstream_done
  4478.                 || (p->upstream_eof && p->length == -1))
  4479.             {
  4480.                 ngx_http_upstream_finalize_request(r, u, 0);
  4481.                 return;
  4482.             }

  4484.             if (p->upstream_eof) {
  4485.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  4486.                               "upstream prematurely closed connection");
  4487.             }

  4489.             ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
  4490.             return;
  4491.         }
  4492.     }

  4494.     if (p->downstream_error) {
  4495.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4496.                        "http upstream downstream error");

  4498.         if (!u->cacheable && !u->store && u->peer.connection) {
  4499.             ngx_http_upstream_finalize_request(r, u, NGX_ERROR);
  4500.         }
  4501.     }
  4502. }


  4505. static void
  4506. ‌ngx_http_upstream_store(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4507. {
  4508.     size_t                  root;
  4509.     time_t                  lm;
  4510.     ngx_str_t               path;
  4511.     ngx_temp_file_t        *tf;
  4512.     ngx_ext_rename_file_t   ext;

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

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

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

  4520.         tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
  4521.         if (tf == NULL) {
  4522.             return;
  4523.         }

  4525.         tf->file.fd = NGX_INVALID_FILE;
  4526.         tf->file.log = r->connection->log;
  4527.         tf->path = u->conf->temp_path;
  4528.         tf->pool = r->pool;
  4529.         tf->persistent = 1;

  4531.         if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
  4532.                                  tf->persistent, tf->clean, tf->access)
  4533.             != NGX_OK)
  4534.         {
  4535.             return;
  4536.         }

  4538.         u->pipe->temp_file = tf;
  4539.     }

  4541.     ext.access = u->conf->store_access;
  4542.     ext.path_access = u->conf->store_access;
  4543.     ext.time = -1;
  4544.     ext.create_path = 1;
  4545.     ext.delete_file = 1;
  4546.     ext.log = r->connection->log;

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

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

  4553.         if (lm != NGX_ERROR) {
  4554.             ext.time = lm;
  4555.             ext.fd = tf->file.fd;
  4556.         }
  4557.     }

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

  4561.         if (ngx_http_map_uri_to_path(r, &path, &root, 0) == NULL) {
  4562.             return;
  4563.         }

  4565.     } else {
  4566.         if (ngx_http_script_run(r, &path, u->conf->store_lengths->elts, 0,
  4567.                                 u->conf->store_values->elts)
  4568.             == NULL)
  4569.         {
  4570.             return;
  4571.         }
  4572.     }

  4574.     path.len--;

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

  4580.     if (path.len == 0) {
  4581.         return;
  4582.     }

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

  4586.     u->store = 0;
  4587. }


  4590. static void
  4591. ‌ngx_http_upstream_dummy_handler(ngx_http_request_t *r, ngx_http_upstream_t *u)
  4592. {
  4593.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4594.                    "http upstream dummy handler");
  4595. }


  4598. static void
  4599. ‌ngx_http_upstream_next(ngx_http_request_t *r, ngx_http_upstream_t *u,
  4600.     ngx_uint_t ft_type)
  4601. {
  4602.     ngx_msec_t  timeout;
  4603.     ngx_uint_t  status, state;

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

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

  4610.         if (u->peer.connection) {
  4611.             u->state->bytes_sent = u->peer.connection->sent;
  4612.         }

  4614.         if (ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_403
  4615.             || ft_type == NGX_HTTP_UPSTREAM_FT_HTTP_404)
  4616.         {
  4617.             state = NGX_PEER_NEXT;

  4619.         } else {
  4620.             state = NGX_PEER_FAILED;
  4621.         }

  4623.         u->peer.free(&u->peer, u->peer.data, state);
  4624.         u->peer.sockaddr = NULL;

  4626. #if (NGX_HTTP_UPSTREAM_SID)
  4627.         u->peer.sid = NULL;
  4628. #endif
  4629.     }

  4631.     if (ft_type == NGX_HTTP_UPSTREAM_FT_TIMEOUT) {
  4632.         ngx_log_error(NGX_LOG_ERR, r->connection->log, NGX_ETIMEDOUT,
  4633.                       "upstream timed out");
  4634.     }

  4636.     if (u->peer.cached && ft_type == NGX_HTTP_UPSTREAM_FT_ERROR) {
  4637.         /* TODO: inform balancer instead */
  4638.         u->peer.tries++;
  4639.     }

  4641.     switch (ft_type) {

  4643.     case NGX_HTTP_UPSTREAM_FT_TIMEOUT:
  4644.     case NGX_HTTP_UPSTREAM_FT_HTTP_504:
  4645.         status = NGX_HTTP_GATEWAY_TIME_OUT;
  4646.         break;

  4648.     case NGX_HTTP_UPSTREAM_FT_HTTP_500:
  4649.         status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4650.         break;

  4652.     case NGX_HTTP_UPSTREAM_FT_HTTP_503:
  4653.         status = NGX_HTTP_SERVICE_UNAVAILABLE;
  4654.         break;

  4656.     case NGX_HTTP_UPSTREAM_FT_HTTP_403:
  4657.         status = NGX_HTTP_FORBIDDEN;
  4658.         break;

  4660.     case NGX_HTTP_UPSTREAM_FT_HTTP_404:
  4661.         status = NGX_HTTP_NOT_FOUND;
  4662.         break;

  4664.     case NGX_HTTP_UPSTREAM_FT_HTTP_429:
  4665.         status = NGX_HTTP_TOO_MANY_REQUESTS;
  4666.         break;

  4668.     /*
  4669.      * NGX_HTTP_UPSTREAM_FT_BUSY_LOCK and NGX_HTTP_UPSTREAM_FT_MAX_WAITING
  4670.      * never reach here
  4671.      */

  4673.     default:
  4674.         status = NGX_HTTP_BAD_GATEWAY;
  4675.     }

  4677.     if (r->connection->error) {
  4678.         ngx_http_upstream_finalize_request(r, u,
  4679.                                            NGX_HTTP_CLIENT_CLOSED_REQUEST);
  4680.         return;
  4681.     }

  4683.     u->state->status = status;

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

  4687.     if (u->request_sent
  4688.         && (r->method & (NGX_HTTP_POST|NGX_HTTP_LOCK|NGX_HTTP_PATCH)))
  4689.     {
  4690.         ft_type |= NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT;
  4691.     }

  4693.     if (u->peer.tries == 0
  4694.         || ((u->conf->next_upstream & ft_type) != ft_type)
  4695.         || (u->request_sent && r->request_body_no_buffering)
  4696.         || (timeout && ngx_current_msec - u->peer.start_time >= timeout))
  4697.     {
  4698. #if (NGX_HTTP_CACHE)

  4700.         if (u->cache_status == NGX_HTTP_CACHE_EXPIRED
  4701.             && ((u->conf->cache_use_stale & ft_type) || r->cache->stale_error))
  4702.         {
  4703.             ngx_int_t  rc;

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

  4707.             if (rc != NGX_OK) {
  4708.                 ngx_http_upstream_finalize_request(r, u, rc);
  4709.                 return;
  4710.             }

  4712.             u->cache_status = NGX_HTTP_CACHE_STALE;
  4713.             rc = ngx_http_upstream_cache_send(r, u);

  4715.             if (rc == NGX_DONE) {
  4716.                 return;
  4717.             }

  4719.             if (rc == NGX_HTTP_UPSTREAM_INVALID_HEADER) {
  4720.                 rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
  4721.             }

  4723.             ngx_http_upstream_finalize_request(r, u, rc);
  4724.             return;
  4725.         }
  4726. #endif

  4728.         ngx_http_upstream_finalize_request(r, u, status);
  4729.         return;
  4730.     }

  4732.     if (u->peer.connection) {
  4733.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4734.                        "close http upstream connection: %d",
  4735.                        u->peer.connection->fd);
  4736. #if (NGX_HTTP_SSL)

  4738.         if (u->peer.connection->ssl) {
  4739.             u->peer.connection->ssl->no_wait_shutdown = 1;
  4740.             u->peer.connection->ssl->no_send_shutdown = 1;

  4742.             (void) ngx_ssl_shutdown(u->peer.connection);
  4743.         }
  4744. #endif

  4746.         if (u->peer.connection->pool) {
  4747.             ngx_destroy_pool(u->peer.connection->pool);
  4748.         }

  4750.         ngx_close_connection(u->peer.connection);
  4751.         u->peer.connection = NULL;
  4752.     }

  4754.     ngx_http_upstream_connect(r, u);
  4755. }


  4758. static void
  4759. ‌ngx_http_upstream_cleanup(void *data)
  4760. {
  4761.     ngx_http_request_t *r = data;

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

  4766.     ngx_http_upstream_finalize_request(r, r->upstream, NGX_DONE);
  4767. }


  4770. static void
  4771. ‌ngx_http_upstream_finalize_request(ngx_http_request_t *r,
  4772.     ngx_http_upstream_t *u, ngx_int_t rc)
  4773. {
  4774.     ngx_uint_t  flush;

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

  4779.     if (u->cleanup == NULL) {
  4780.         /* the request was already finalized */
  4781.         ngx_http_finalize_request(r, NGX_DONE);
  4782.         return;
  4783.     }

  4785.     *u->cleanup = NULL;
  4786.     u->cleanup = NULL;

  4788.     if (u->resolved && u->resolved->ctx) {
  4789.         ngx_resolve_name_done(u->resolved->ctx);
  4790.         u->resolved->ctx = NULL;
  4791.     }

  4793.     if (u->state && u->state->response_time == (ngx_msec_t) -1) {
  4794.         u->state->response_time = ngx_current_msec - u->start_time;

  4796.         if (u->pipe && u->pipe->read_length) {
  4797.             u->state->bytes_received += u->pipe->read_length
  4798.                                         - u->pipe->preread_size;
  4799.             u->state->response_length = u->pipe->read_length;
  4800.         }

  4802.         if (u->peer.connection) {
  4803.             u->state->bytes_sent = u->peer.connection->sent;
  4804.         }
  4805.     }

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

  4809.     if (u->peer.free && u->peer.sockaddr) {
  4810.         u->peer.free(&u->peer, u->peer.data, 0);
  4811.         u->peer.sockaddr = NULL;

  4813. #if (NGX_HTTP_UPSTREAM_SID)
  4814.         u->peer.sid = NULL;
  4815. #endif
  4816.     }

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

  4820. #if (NGX_HTTP_SSL)

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

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

  4826.             /*
  4827.              * We send the "close notify" shutdown alert to the upstream only
  4828.              * and do not wait its "close notify" shutdown alert.
  4829.              * It is acceptable according to the TLS standard.
  4830.              */

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

  4834.             (void) ngx_ssl_shutdown(u->peer.connection);
  4835.         }
  4836. #endif

  4838.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4839.                        "close http upstream connection: %d",
  4840.                        u->peer.connection->fd);

  4842.         if (u->peer.connection->pool) {
  4843.             ngx_destroy_pool(u->peer.connection->pool);
  4844.         }

  4846.         ngx_close_connection(u->peer.connection);
  4847.     }

  4849.     u->peer.connection = NULL;

  4851.     if (u->pipe) {
  4852.         u->pipe->upstream = NULL;
  4853.     }

  4855.     if (u->pipe && u->pipe->temp_file) {
  4856.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  4857.                        "http upstream temp fd: %d",
  4858.                        u->pipe->temp_file->file.fd);
  4859.     }

  4861.     if (u->store && u->pipe && u->pipe->temp_file
  4862.         && u->pipe->temp_file->file.fd != NGX_INVALID_FILE)
  4863.     {
  4864.         if (ngx_delete_file(u->pipe->temp_file->file.name.data)
  4865.             == NGX_FILE_ERROR)
  4866.         {
  4867.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  4868.                           ngx_delete_file_n " \"%s\" failed",
  4869.                           u->pipe->temp_file->file.name.data);
  4870.         }
  4871.     }

  4873. #if (NGX_HTTP_CACHE)

  4875.     if (r->cache) {

  4877.         if (u->cacheable) {

  4879.             if (rc == NGX_HTTP_BAD_GATEWAY || rc == NGX_HTTP_GATEWAY_TIME_OUT) {
  4880.                 time_t  valid;

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

  4884.                 if (valid) {
  4885.                     r->cache->valid_sec = ngx_time() + valid;
  4886.                     r->cache->error = rc;
  4887.                 }
  4888.             }
  4889.         }

  4891.         ngx_http_file_cache_free(r->cache, u->pipe->temp_file);
  4892.     }

  4894. #endif

  4896.     r->read_event_handler = ngx_http_block_reading;

  4898.     if (rc == NGX_DECLINED) {
  4899.         return;
  4900.     }

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

  4904.     if (!u->header_sent
  4905.         || rc == NGX_HTTP_REQUEST_TIME_OUT
  4906.         || rc == NGX_HTTP_CLIENT_CLOSED_REQUEST)
  4907.     {
  4908.         ngx_http_finalize_request(r, rc);
  4909.         return;
  4910.     }

  4912.     flush = 0;

  4914.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  4915.         rc = NGX_ERROR;
  4916.         flush = 1;
  4917.     }

  4919.     if (r->header_only
  4920.         || (u->pipe && u->pipe->downstream_error))
  4921.     {
  4922.         ngx_http_finalize_request(r, rc);
  4923.         return;
  4924.     }

  4926.     if (rc == 0) {

  4928.         if (ngx_http_upstream_process_trailers(r, u) != NGX_OK) {
  4929.             ngx_http_finalize_request(r, NGX_ERROR);
  4930.             return;
  4931.         }

  4933.         rc = ngx_http_send_special(r, NGX_HTTP_LAST);

  4935.     } else if (flush) {
  4936.         r->keepalive = 0;
  4937.         rc = ngx_http_send_special(r, NGX_HTTP_FLUSH);
  4938.     }

  4940.     ngx_http_finalize_request(r, rc);
  4941. }


  4944. static ngx_int_t
  4945. ‌ngx_http_upstream_process_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4946.     ngx_uint_t offset)
  4947. {
  4948.     ngx_table_elt_t  **ph;

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

  4952.     if (*ph) {
  4953.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  4954.                       "upstream sent duplicate header line: \"%V: %V\", "
  4955.                       "previous value: \"%V: %V\", ignored",
  4956.                       &h->key, &h->value,
  4957.                       &(*ph)->key, &(*ph)->value);
  4958.         h->hash = 0;
  4959.         return NGX_OK;
  4960.     }

  4962.     *ph = h;
  4963.     h->next = NULL;

  4965.     return NGX_OK;
  4966. }


  4969. static ngx_int_t
  4970. ‌ngx_http_upstream_process_multi_header_lines(ngx_http_request_t *r,
  4971.     ngx_table_elt_t *h, ngx_uint_t offset)
  4972. {
  4973.     ngx_table_elt_t  **ph;

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

  4977.     while (*ph) { ph = &(*ph)->next; }

  4979.     *ph = h;
  4980.     h->next = NULL;

  4982.     return NGX_OK;
  4983. }


  4986. static ngx_int_t
  4987. ‌ngx_http_upstream_ignore_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  4988.     ngx_uint_t offset)
  4989. {
  4990.     return NGX_OK;
  4991. }


  4994. static ngx_int_t
  4995. ‌ngx_http_upstream_process_content_length(ngx_http_request_t *r,
  4996.     ngx_table_elt_t *h, ngx_uint_t offset)
  4997. {
  4998.     ngx_http_upstream_t  *u;

  5000.     u = r->upstream;

  5002.     if (u->headers_in.content_length) {
  5003.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5004.                       "upstream sent duplicate header line: \"%V: %V\", "
  5005.                       "previous value: \"%V: %V\"",
  5006.                       &h->key, &h->value,
  5007.                       &u->headers_in.content_length->key,
  5008.                       &u->headers_in.content_length->value);
  5009.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5010.     }

  5012.     if (u->headers_in.transfer_encoding) {
  5013.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5014.                       "upstream sent \"Content-Length\" and "
  5015.                       "\"Transfer-Encoding\" headers at the same time");
  5016.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5017.     }

  5019.     h->next = NULL;
  5020.     u->headers_in.content_length = h;
  5021.     u->headers_in.content_length_n = ngx_atoof(h->value.data, h->value.len);

  5023.     if (u->headers_in.content_length_n == NGX_ERROR) {
  5024.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5025.                       "upstream sent invalid \"Content-Length\" header: "
  5026.                       "\"%V: %V\"", &h->key, &h->value);
  5027.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5028.     }

  5030.     return NGX_OK;
  5031. }


  5034. static ngx_int_t
  5035. ‌ngx_http_upstream_process_last_modified(ngx_http_request_t *r,
  5036.     ngx_table_elt_t *h, ngx_uint_t offset)
  5037. {
  5038.     ngx_http_upstream_t  *u;

  5040.     u = r->upstream;

  5042.     if (u->headers_in.last_modified) {
  5043.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5044.                       "upstream sent duplicate header line: \"%V: %V\", "
  5045.                       "previous value: \"%V: %V\", ignored",
  5046.                       &h->key, &h->value,
  5047.                       &u->headers_in.last_modified->key,
  5048.                       &u->headers_in.last_modified->value);
  5049.         h->hash = 0;
  5050.         return NGX_OK;
  5051.     }

  5053.     h->next = NULL;
  5054.     u->headers_in.last_modified = h;
  5055.     u->headers_in.last_modified_time = ngx_parse_http_time(h->value.data,
  5056.                                                            h->value.len);

  5058.     return NGX_OK;
  5059. }


  5062. static ngx_int_t
  5063. ‌ngx_http_upstream_process_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5064.     ngx_uint_t offset)
  5065. {
  5066.     ngx_table_elt_t      **ph;
  5067.     ngx_http_upstream_t   *u;

  5069.     u = r->upstream;
  5070.     ph = &u->headers_in.set_cookie;

  5072.     while (*ph) { ph = &(*ph)->next; }

  5074.     *ph = h;
  5075.     h->next = NULL;

  5077. #if (NGX_HTTP_CACHE)
  5078.     if (!(u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_SET_COOKIE)) {
  5079.         u->cacheable = 0;
  5080.     }
  5081. #endif

  5083.     return NGX_OK;
  5084. }


  5087. static ngx_int_t
  5088. ‌ngx_http_upstream_process_cache_control(ngx_http_request_t *r,
  5089.     ngx_table_elt_t *h, ngx_uint_t offset)
  5090. {
  5091.     ngx_table_elt_t      **ph;
  5092.     ngx_http_upstream_t   *u;

  5094.     u = r->upstream;
  5095.     ph = &u->headers_in.cache_control;

  5097.     while (*ph) { ph = &(*ph)->next; }

  5099.     *ph = h;
  5100.     h->next = NULL;

  5102. #if (NGX_HTTP_CACHE)
  5103.     {
  5104.     u_char     *p, *start, *last;
  5105.     ngx_int_t   n;

  5107.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_CACHE_CONTROL) {
  5108.         return NGX_OK;
  5109.     }

  5111.     if (r->cache == NULL) {
  5112.         return NGX_OK;
  5113.     }

  5115.     start = h->value.data;
  5116.     last = start + h->value.len;

  5118.     if (r->cache->valid_sec != 0 && u->headers_in.x_accel_expires != NULL) {
  5119.         goto extensions;
  5120.     }

  5122.     if (ngx_strlcasestrn(start, last, (u_char *) "no-cache", 8 - 1) != NULL
  5123.         || ngx_strlcasestrn(start, last, (u_char *) "no-store", 8 - 1) != NULL
  5124.         || ngx_strlcasestrn(start, last, (u_char *) "private", 7 - 1) != NULL)
  5125.     {
  5126.         u->headers_in.no_cache = 1;
  5127.         return NGX_OK;
  5128.     }

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

  5133.     if (p == NULL) {
  5134.         p = ngx_strlcasestrn(start, last, (u_char *) "max-age=", 8 - 1);
  5135.         offset = 8;
  5136.     }

  5138.     if (p) {
  5139.         n = ngx_http_upstream_process_delta_seconds(p + offset, last);

  5141.         if (n == NGX_ERROR) {
  5142.             u->cacheable = 0;
  5143.             return NGX_OK;
  5144.         }

  5146.         if (n == 0) {
  5147.             u->headers_in.no_cache = 1;
  5148.             return NGX_OK;
  5149.         }

  5151.         r->cache->valid_sec = ngx_min((ngx_uint_t) ngx_time() + n,
  5152.                                       NGX_MAX_INT_T_VALUE);
  5153.         u->headers_in.expired = 0;
  5154.     }

  5156. extensions:

  5158.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-while-revalidate=",
  5159.                          23 - 1);

  5161.     if (p) {
  5162.         n = ngx_http_upstream_process_delta_seconds(p + 23, last);

  5164.         if (n == NGX_ERROR) {
  5165.             u->cacheable = 0;
  5166.             return NGX_OK;
  5167.         }

  5169.         r->cache->updating_sec = n;
  5170.         r->cache->error_sec = n;
  5171.     }

  5173.     p = ngx_strlcasestrn(start, last, (u_char *) "stale-if-error=", 15 - 1);

  5175.     if (p) {
  5176.         n = ngx_http_upstream_process_delta_seconds(p + 15, last);

  5178.         if (n == NGX_ERROR) {
  5179.             u->cacheable = 0;
  5180.             return NGX_OK;
  5181.         }

  5183.         r->cache->error_sec = n;
  5184.     }
  5185.     }
  5186. #endif

  5188.     return NGX_OK;
  5189. }


  5192. #if (NGX_HTTP_CACHE)

  5194. static ngx_int_t
  5195. ‌ngx_http_upstream_process_delta_seconds(u_char *p, u_char *last)
  5196. {
  5197.     ngx_int_t  n, cutoff, cutlim;

  5199.     cutoff = NGX_MAX_INT_T_VALUE / 10;
  5200.     cutlim = NGX_MAX_INT_T_VALUE % 10;

  5202.     n = 0;

  5204.     for ( /* void */ ; p < last; p++) {
  5205.         if (*p == ',' || *p == ';' || *p == ' ') {
  5206.             break;
  5207.         }

  5209.         if (*p < '0' || *p > '9') {
  5210.             return NGX_ERROR;
  5211.         }

  5213.         if (n >= cutoff && (n > cutoff || *p - '0' > cutlim)) {
  5214.             n = NGX_MAX_INT_T_VALUE;
  5215.             break;
  5216.         }

  5218.         n = n * 10 + (*p - '0');
  5219.     }

  5221.     return n;
  5222. }

  5224. #endif


  5227. static ngx_int_t
  5228. ‌ngx_http_upstream_process_expires(ngx_http_request_t *r, ngx_table_elt_t *h,
  5229.     ngx_uint_t offset)
  5230. {
  5231.     ngx_http_upstream_t  *u;

  5233.     u = r->upstream;

  5235.     if (u->headers_in.expires) {
  5236.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5237.                       "upstream sent duplicate header line: \"%V: %V\", "
  5238.                       "previous value: \"%V: %V\", ignored",
  5239.                       &h->key, &h->value,
  5240.                       &u->headers_in.expires->key,
  5241.                       &u->headers_in.expires->value);
  5242.         h->hash = 0;
  5243.         return NGX_OK;
  5244.     }

  5246.     u->headers_in.expires = h;
  5247.     h->next = NULL;

  5249. #if (NGX_HTTP_CACHE)
  5250.     {
  5251.     time_t  expires;

  5253.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_EXPIRES) {
  5254.         return NGX_OK;
  5255.     }

  5257.     if (r->cache == NULL) {
  5258.         return NGX_OK;
  5259.     }

  5261.     if (r->cache->valid_sec != 0) {
  5262.         return NGX_OK;
  5263.     }

  5265.     expires = ngx_parse_http_time(h->value.data, h->value.len);

  5267.     if (expires == NGX_ERROR || expires < ngx_time()) {
  5268.         u->headers_in.expired = 1;
  5269.         return NGX_OK;
  5270.     }

  5272.     r->cache->valid_sec = expires;
  5273.     }
  5274. #endif

  5276.     return NGX_OK;
  5277. }


  5280. static ngx_int_t
  5281. ‌ngx_http_upstream_process_accel_expires(ngx_http_request_t *r,
  5282.     ngx_table_elt_t *h, ngx_uint_t offset)
  5283. {
  5284.     ngx_http_upstream_t  *u;

  5286.     u = r->upstream;

  5288.     if (u->headers_in.x_accel_expires) {
  5289.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5290.                       "upstream sent duplicate header line: \"%V: %V\", "
  5291.                       "previous value: \"%V: %V\", ignored",
  5292.                       &h->key, &h->value,
  5293.                       &u->headers_in.x_accel_expires->key,
  5294.                       &u->headers_in.x_accel_expires->value);
  5295.         h->hash = 0;
  5296.         return NGX_OK;
  5297.     }

  5299.     u->headers_in.x_accel_expires = h;
  5300.     h->next = NULL;

  5302. #if (NGX_HTTP_CACHE)
  5303.     {
  5304.     u_char     *p;
  5305.     size_t      len;
  5306.     ngx_int_t   n;

  5308.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_EXPIRES) {
  5309.         return NGX_OK;
  5310.     }

  5312.     if (r->cache == NULL) {
  5313.         return NGX_OK;
  5314.     }

  5316.     len = h->value.len;
  5317.     p = h->value.data;

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

  5322.         switch (n) {
  5323.         case 0:
  5324.             u->cacheable = 0;
  5325.             /* fall through */

  5327.         case NGX_ERROR:
  5328.             return NGX_OK;

  5330.         default:
  5331.             r->cache->valid_sec = ngx_time() + n;
  5332.             u->headers_in.no_cache = 0;
  5333.             u->headers_in.expired = 0;
  5334.             return NGX_OK;
  5335.         }
  5336.     }

  5338.     p++;
  5339.     len--;

  5341.     n = ngx_atoi(p, len);

  5343.     if (n != NGX_ERROR) {
  5344.         r->cache->valid_sec = n;
  5345.         u->headers_in.no_cache = 0;
  5346.         u->headers_in.expired = 0;
  5347.     }
  5348.     }
  5349. #endif

  5351.     return NGX_OK;
  5352. }


  5355. static ngx_int_t
  5356. ‌ngx_http_upstream_process_limit_rate(ngx_http_request_t *r, ngx_table_elt_t *h,
  5357.     ngx_uint_t offset)
  5358. {
  5359.     ngx_int_t             n;
  5360.     ngx_http_upstream_t  *u;

  5362.     u = r->upstream;

  5364.     if (u->headers_in.x_accel_limit_rate) {
  5365.         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  5366.                       "upstream sent duplicate header line: \"%V: %V\", "
  5367.                       "previous value: \"%V: %V\", ignored",
  5368.                       &h->key, &h->value,
  5369.                       &u->headers_in.x_accel_limit_rate->key,
  5370.                       &u->headers_in.x_accel_limit_rate->value);
  5371.         h->hash = 0;
  5372.         return NGX_OK;
  5373.     }

  5375.     u->headers_in.x_accel_limit_rate = h;
  5376.     h->next = NULL;

  5378.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_LIMIT_RATE) {
  5379.         return NGX_OK;
  5380.     }

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

  5384.     if (n != NGX_ERROR) {
  5385.         r->limit_rate = (size_t) n;
  5386.         r->limit_rate_set = 1;
  5387.     }

  5389.     return NGX_OK;
  5390. }


  5393. static ngx_int_t
  5394. ‌ngx_http_upstream_process_buffering(ngx_http_request_t *r, ngx_table_elt_t *h,
  5395.     ngx_uint_t offset)
  5396. {
  5397.     u_char                c0, c1, c2;
  5398.     ngx_http_upstream_t  *u;

  5400.     u = r->upstream;

  5402.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_BUFFERING) {
  5403.         return NGX_OK;
  5404.     }

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

  5408.         if (h->value.len == 2) {
  5409.             c0 = ngx_tolower(h->value.data[0]);
  5410.             c1 = ngx_tolower(h->value.data[1]);

  5412.             if (c0 == 'n' && c1 == 'o') {
  5413.                 u->buffering = 0;
  5414.             }

  5416.         } else if (h->value.len == 3) {
  5417.             c0 = ngx_tolower(h->value.data[0]);
  5418.             c1 = ngx_tolower(h->value.data[1]);
  5419.             c2 = ngx_tolower(h->value.data[2]);

  5421.             if (c0 == 'y' && c1 == 'e' && c2 == 's') {
  5422.                 u->buffering = 1;
  5423.             }
  5424.         }
  5425.     }

  5427.     return NGX_OK;
  5428. }


  5431. static ngx_int_t
  5432. ‌ngx_http_upstream_process_charset(ngx_http_request_t *r, ngx_table_elt_t *h,
  5433.     ngx_uint_t offset)
  5434. {
  5435.     ngx_http_upstream_t  *u;

  5437.     u = r->upstream;

  5439.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_XA_CHARSET) {
  5440.         return NGX_OK;
  5441.     }

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

  5445.     return NGX_OK;
  5446. }


  5449. static ngx_int_t
  5450. ‌ngx_http_upstream_process_connection(ngx_http_request_t *r, ngx_table_elt_t *h,
  5451.     ngx_uint_t offset)
  5452. {
  5453.     ngx_table_elt_t      **ph;
  5454.     ngx_http_upstream_t   *u;

  5456.     u = r->upstream;
  5457.     ph = &u->headers_in.connection;

  5459.     while (*ph) { ph = &(*ph)->next; }

  5461.     *ph = h;
  5462.     h->next = NULL;

  5464.     if (ngx_strlcasestrn(h->value.data, h->value.data + h->value.len,
  5465.                          (u_char *) "close", 5 - 1)
  5466.         != NULL)
  5467.     {
  5468.         u->headers_in.connection_close = 1;
  5469.     }

  5471.     return NGX_OK;
  5472. }


  5475. static ngx_int_t
  5476. ‌ngx_http_upstream_process_transfer_encoding(ngx_http_request_t *r,
  5477.     ngx_table_elt_t *h, ngx_uint_t offset)
  5478. {
  5479.     ngx_http_upstream_t  *u;

  5481.     u = r->upstream;

  5483.     if (u->headers_in.transfer_encoding) {
  5484.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5485.                       "upstream sent duplicate header line: \"%V: %V\", "
  5486.                       "previous value: \"%V: %V\"",
  5487.                       &h->key, &h->value,
  5488.                       &u->headers_in.transfer_encoding->key,
  5489.                       &u->headers_in.transfer_encoding->value);
  5490.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5491.     }

  5493.     if (u->headers_in.content_length) {
  5494.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5495.                       "upstream sent \"Content-Length\" and "
  5496.                       "\"Transfer-Encoding\" headers at the same time");
  5497.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5498.     }

  5500.     u->headers_in.transfer_encoding = h;
  5501.     h->next = NULL;

  5503.     if (h->value.len == 7
  5504.         && ngx_strncasecmp(h->value.data, (u_char *) "chunked", 7) == 0)
  5505.     {
  5506.         u->headers_in.chunked = 1;

  5508.     } else {
  5509.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  5510.                       "upstream sent unknown \"Transfer-Encoding\": \"%V\"",
  5511.                       &h->value);
  5512.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  5513.     }

  5515.     return NGX_OK;
  5516. }


  5519. static ngx_int_t
  5520. ‌ngx_http_upstream_process_vary(ngx_http_request_t *r,
  5521.     ngx_table_elt_t *h, ngx_uint_t offset)
  5522. {
  5523.     ngx_table_elt_t      **ph;
  5524.     ngx_http_upstream_t   *u;

  5526.     u = r->upstream;
  5527.     ph = &u->headers_in.vary;

  5529.     while (*ph) { ph = &(*ph)->next; }

  5531.     *ph = h;
  5532.     h->next = NULL;

  5534. #if (NGX_HTTP_CACHE)
  5535.     {
  5536.     u_char     *p;
  5537.     size_t      len;
  5538.     ngx_str_t   vary;

  5540.     if (u->conf->ignore_headers & NGX_HTTP_UPSTREAM_IGN_VARY) {
  5541.         return NGX_OK;
  5542.     }

  5544.     if (r->cache == NULL || !u->cacheable) {
  5545.         return NGX_OK;
  5546.     }

  5548.     if (h->value.len == 1 && h->value.data[0] == '*') {
  5549.         u->cacheable = 0;
  5550.         return NGX_OK;
  5551.     }

  5553.     if (u->headers_in.vary->next) {

  5555.         len = 0;

  5557.         for (h = u->headers_in.vary; h; h = h->next) {
  5558.             len += h->value.len + 2;
  5559.         }

  5561.         len -= 2;

  5563.         p = ngx_pnalloc(r->pool, len);
  5564.         if (p == NULL) {
  5565.             return NGX_ERROR;
  5566.         }

  5568.         vary.len = len;
  5569.         vary.data = p;

  5571.         for (h = u->headers_in.vary; h; h = h->next) {
  5572.             p = ngx_copy(p, h->value.data, h->value.len);

  5574.             if (h->next == NULL) {
  5575.                 break;
  5576.             }

  5578.             *p++ = ','; *p++ = ' ';
  5579.         }

  5581.     } else {
  5582.         vary = h->value;
  5583.     }

  5585.     if (vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  5586.         u->cacheable = 0;
  5587.     }

  5589.     r->cache->vary = vary;
  5590.     }
  5591. #endif

  5593.     return NGX_OK;
  5594. }


  5597. static ngx_int_t
  5598. ‌ngx_http_upstream_copy_header_line(ngx_http_request_t *r, ngx_table_elt_t *h,
  5599.     ngx_uint_t offset)
  5600. {
  5601.     ngx_table_elt_t  *ho, **ph;

  5603.     ho = ngx_list_push(&r->headers_out.headers);
  5604.     if (ho == NULL) {
  5605.         return NGX_ERROR;
  5606.     }

  5608.     *ho = *h;

  5610.     if (offset) {
  5611.         ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);
  5612.         *ph = ho;
  5613.         ho->next = NULL;
  5614.     }

  5616.     return NGX_OK;
  5617. }


  5620. static ngx_int_t
  5621. ‌ngx_http_upstream_copy_multi_header_lines(ngx_http_request_t *r,
  5622.     ngx_table_elt_t *h, ngx_uint_t offset)
  5623. {
  5624.     ngx_table_elt_t  *ho, **ph;

  5626.     ho = ngx_list_push(&r->headers_out.headers);
  5627.     if (ho == NULL) {
  5628.         return NGX_ERROR;
  5629.     }

  5631.     *ho = *h;

  5633.     ph = (ngx_table_elt_t **) ((char *) &r->headers_out + offset);

  5635.     while (*ph) { ph = &(*ph)->next; }

  5637.     *ph = ho;
  5638.     ho->next = NULL;

  5640.     return NGX_OK;
  5641. }


  5644. static ngx_int_t
  5645. ‌ngx_http_upstream_copy_content_type(ngx_http_request_t *r, ngx_table_elt_t *h,
  5646.     ngx_uint_t offset)
  5647. {
  5648.     u_char  *p, *last;

  5650.     r->headers_out.content_type_len = h->value.len;
  5651.     r->headers_out.content_type = h->value;
  5652.     r->headers_out.content_type_lowcase = NULL;

  5654.     for (p = h->value.data; *p; p++) {

  5656.         if (*p != ';') {
  5657.             continue;
  5658.         }

  5660.         last = p;

  5662.         while (*++p == ' ') { /* void */ }

  5664.         if (*p == '\0') {
  5665.             return NGX_OK;
  5666.         }

  5668.         if (ngx_strncasecmp(p, (u_char *) "charset=", 8) != 0) {
  5669.             continue;
  5670.         }

  5672.         p += 8;

  5674.         r->headers_out.content_type_len = last - h->value.data;

  5676.         if (*p == '"') {
  5677.             p++;
  5678.         }

  5680.         last = h->value.data + h->value.len;

  5682.         if (last > p && *(last - 1) == '"') {
  5683.             last--;
  5684.         }

  5686.         r->headers_out.charset.len = last - p;
  5687.         r->headers_out.charset.data = p;

  5689.         return NGX_OK;
  5690.     }

  5692.     return NGX_OK;
  5693. }


  5696. static ngx_int_t
  5697. ‌ngx_http_upstream_copy_last_modified(ngx_http_request_t *r, ngx_table_elt_t *h,
  5698.     ngx_uint_t offset)
  5699. {
  5700.     ngx_table_elt_t  *ho;

  5702.     ho = ngx_list_push(&r->headers_out.headers);
  5703.     if (ho == NULL) {
  5704.         return NGX_ERROR;
  5705.     }

  5707.     *ho = *h;
  5708.     ho->next = NULL;

  5710.     r->headers_out.last_modified = ho;
  5711.     r->headers_out.last_modified_time =
  5712.                                     r->upstream->headers_in.last_modified_time;

  5714.     return NGX_OK;
  5715. }


  5718. static ngx_int_t
  5719. ‌ngx_http_upstream_rewrite_location(ngx_http_request_t *r, ngx_table_elt_t *h,
  5720.     ngx_uint_t offset)
  5721. {
  5722.     ngx_int_t         rc;
  5723.     ngx_table_elt_t  *ho;

  5725.     ho = ngx_list_push(&r->headers_out.headers);
  5726.     if (ho == NULL) {
  5727.         return NGX_ERROR;
  5728.     }

  5730.     *ho = *h;
  5731.     ho->next = NULL;

  5733.     if (r->upstream->rewrite_redirect) {
  5734.         rc = r->upstream->rewrite_redirect(r, ho, 0);

  5736.         if (rc == NGX_DECLINED) {
  5737.             return NGX_OK;
  5738.         }

  5740.         if (rc == NGX_OK) {
  5741.             r->headers_out.location = ho;

  5743.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5744.                            "rewritten location: \"%V\"", &ho->value);
  5745.         }

  5747.         return rc;
  5748.     }

  5750.     if (ho->value.data[0] != '/') {
  5751.         r->headers_out.location = ho;
  5752.     }

  5754.     /*
  5755.      * we do not set r->headers_out.location here to avoid handling
  5756.      * relative redirects in ngx_http_header_filter()
  5757.      */

  5759.     return NGX_OK;
  5760. }


  5763. static ngx_int_t
  5764. ‌ngx_http_upstream_rewrite_refresh(ngx_http_request_t *r, ngx_table_elt_t *h,
  5765.     ngx_uint_t offset)
  5766. {
  5767.     u_char           *p;
  5768.     ngx_int_t         rc;
  5769.     ngx_table_elt_t  *ho;

  5771.     ho = ngx_list_push(&r->headers_out.headers);
  5772.     if (ho == NULL) {
  5773.         return NGX_ERROR;
  5774.     }

  5776.     *ho = *h;
  5777.     ho->next = NULL;

  5779.     if (r->upstream->rewrite_redirect) {

  5781.         p = ngx_strcasestrn(ho->value.data, "url=", 4 - 1);

  5783.         if (p) {
  5784.             rc = r->upstream->rewrite_redirect(r, ho, p + 4 - ho->value.data);

  5786.         } else {
  5787.             return NGX_OK;
  5788.         }

  5790.         if (rc == NGX_DECLINED) {
  5791.             return NGX_OK;
  5792.         }

  5794.         if (rc == NGX_OK) {
  5795.             r->headers_out.refresh = ho;

  5797.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5798.                            "rewritten refresh: \"%V\"", &ho->value);
  5799.         }

  5801.         return rc;
  5802.     }

  5804.     r->headers_out.refresh = ho;

  5806.     return NGX_OK;
  5807. }


  5810. static ngx_int_t
  5811. ‌ngx_http_upstream_rewrite_set_cookie(ngx_http_request_t *r, ngx_table_elt_t *h,
  5812.     ngx_uint_t offset)
  5813. {
  5814.     ngx_int_t         rc;
  5815.     ngx_table_elt_t  *ho;

  5817.     ho = ngx_list_push(&r->headers_out.headers);
  5818.     if (ho == NULL) {
  5819.         return NGX_ERROR;
  5820.     }

  5822.     *ho = *h;
  5823.     ho->next = NULL;

  5825.     if (r->upstream->rewrite_cookie) {
  5826.         rc = r->upstream->rewrite_cookie(r, ho);

  5828.         if (rc == NGX_DECLINED) {
  5829.             return NGX_OK;
  5830.         }

  5832. #if (NGX_DEBUG)
  5833.         if (rc == NGX_OK) {
  5834.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  5835.                            "rewritten cookie: \"%V\"", &ho->value);
  5836.         }
  5837. #endif

  5839.         return rc;
  5840.     }

  5842.     return NGX_OK;
  5843. }


  5846. static ngx_int_t
  5847. ‌ngx_http_upstream_copy_allow_ranges(ngx_http_request_t *r,
  5848.     ngx_table_elt_t *h, ngx_uint_t offset)
  5849. {
  5850.     ngx_table_elt_t  *ho;

  5852.     if (r->upstream->conf->force_ranges) {
  5853.         return NGX_OK;
  5854.     }

  5856. #if (NGX_HTTP_CACHE)

  5858.     if (r->cached) {
  5859.         r->allow_ranges = 1;
  5860.         return NGX_OK;
  5861.     }

  5863.     if (r->upstream->cacheable) {
  5864.         r->allow_ranges = 1;
  5865.         r->single_range = 1;
  5866.         return NGX_OK;
  5867.     }

  5869. #endif

  5871.     ho = ngx_list_push(&r->headers_out.headers);
  5872.     if (ho == NULL) {
  5873.         return NGX_ERROR;
  5874.     }

  5876.     *ho = *h;
  5877.     ho->next = NULL;

  5879.     r->headers_out.accept_ranges = ho;

  5881.     return NGX_OK;
  5882. }


  5885. static ngx_int_t
  5886. ‌ngx_http_upstream_copy_upgrade(ngx_http_request_t *r, ngx_table_elt_t *h,
  5887.     ngx_uint_t offset)
  5888. {
  5889.     ngx_table_elt_t  *ho;

  5891.     if (r->http_version >= NGX_HTTP_VERSION_20) {
  5892.         return NGX_OK;
  5893.     }

  5895.     ho = ngx_list_push(&r->headers_out.headers);
  5896.     if (ho == NULL) {
  5897.         return NGX_ERROR;
  5898.     }

  5900.     *ho = *h;

  5902.     return NGX_OK;
  5903. }


  5906. static ngx_int_t
  5907. ‌ngx_http_upstream_add_variables(ngx_conf_t *cf)
  5908. {
  5909.     ngx_http_variable_t  *var, *v;

  5911.     for (v = ngx_http_upstream_vars; v->name.len; v++) {
  5912.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  5913.         if (var == NULL) {
  5914.             return NGX_ERROR;
  5915.         }

  5917.         var->get_handler = v->get_handler;
  5918.         var->data = v->data;
  5919.     }

  5921.     return NGX_OK;
  5922. }


  5925. static ngx_int_t
  5926. ‌ngx_http_upstream_addr_variable(ngx_http_request_t *r,
  5927.     ngx_http_variable_value_t *v, uintptr_t data)
  5928. {
  5929.     u_char                     *p;
  5930.     size_t                      len;
  5931.     ngx_uint_t                  i;
  5932.     ngx_http_upstream_state_t  *state;

  5934.     v->valid = 1;
  5935.     v->no_cacheable = 0;
  5936.     v->not_found = 0;

  5938.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  5939.         v->not_found = 1;
  5940.         return NGX_OK;
  5941.     }

  5943.     len = 0;
  5944.     state = r->upstream_states->elts;

  5946.     for (i = 0; i < r->upstream_states->nelts; i++) {
  5947.         if (state[i].peer) {
  5948.             len += state[i].peer->len + 2;

  5950.         } else {
  5951.             len += 3;
  5952.         }
  5953.     }

  5955.     p = ngx_pnalloc(r->pool, len);
  5956.     if (p == NULL) {
  5957.         return NGX_ERROR;
  5958.     }

  5960.     v->data = p;

  5962.     i = 0;

  5964.     for ( ;; ) {
  5965.         if (state[i].peer) {
  5966.             p = ngx_cpymem(p, state[i].peer->data, state[i].peer->len);
  5967.         }

  5969.         if (++i == r->upstream_states->nelts) {
  5970.             break;
  5971.         }

  5973.         if (state[i].peer) {
  5974.             *p++ = ',';
  5975.             *p++ = ' ';

  5977.         } else {
  5978.             *p++ = ' ';
  5979.             *p++ = ':';
  5980.             *p++ = ' ';

  5982.             if (++i == r->upstream_states->nelts) {
  5983.                 break;
  5984.             }

  5986.             continue;
  5987.         }
  5988.     }

  5990.     v->len = p - v->data;

  5992.     return NGX_OK;
  5993. }


  5996. static ngx_int_t
  5997. ‌ngx_http_upstream_status_variable(ngx_http_request_t *r,
  5998.     ngx_http_variable_value_t *v, uintptr_t data)
  5999. {
  6000.     u_char                     *p;
  6001.     size_t                      len;
  6002.     ngx_uint_t                  i;
  6003.     ngx_http_upstream_state_t  *state;

  6005.     v->valid = 1;
  6006.     v->no_cacheable = 0;
  6007.     v->not_found = 0;

  6009.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6010.         v->not_found = 1;
  6011.         return NGX_OK;
  6012.     }

  6014.     len = r->upstream_states->nelts * (3 + 2);

  6016.     p = ngx_pnalloc(r->pool, len);
  6017.     if (p == NULL) {
  6018.         return NGX_ERROR;
  6019.     }

  6021.     v->data = p;

  6023.     i = 0;
  6024.     state = r->upstream_states->elts;

  6026.     for ( ;; ) {
  6027.         if (state[i].status) {
  6028.             p = ngx_sprintf(p, "%ui", state[i].status);

  6030.         } else {
  6031.             *p++ = '-';
  6032.         }

  6034.         if (++i == r->upstream_states->nelts) {
  6035.             break;
  6036.         }

  6038.         if (state[i].peer) {
  6039.             *p++ = ',';
  6040.             *p++ = ' ';

  6042.         } else {
  6043.             *p++ = ' ';
  6044.             *p++ = ':';
  6045.             *p++ = ' ';

  6047.             if (++i == r->upstream_states->nelts) {
  6048.                 break;
  6049.             }

  6051.             continue;
  6052.         }
  6053.     }

  6055.     v->len = p - v->data;

  6057.     return NGX_OK;
  6058. }


  6061. static ngx_int_t
  6062. ‌ngx_http_upstream_response_time_variable(ngx_http_request_t *r,
  6063.     ngx_http_variable_value_t *v, uintptr_t data)
  6064. {
  6065.     u_char                     *p;
  6066.     size_t                      len;
  6067.     ngx_uint_t                  i;
  6068.     ngx_msec_int_t              ms;
  6069.     ngx_http_upstream_state_t  *state;

  6071.     v->valid = 1;
  6072.     v->no_cacheable = 0;
  6073.     v->not_found = 0;

  6075.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6076.         v->not_found = 1;
  6077.         return NGX_OK;
  6078.     }

  6080.     len = r->upstream_states->nelts * (NGX_TIME_T_LEN + 4 + 2);

  6082.     p = ngx_pnalloc(r->pool, len);
  6083.     if (p == NULL) {
  6084.         return NGX_ERROR;
  6085.     }

  6087.     v->data = p;

  6089.     i = 0;
  6090.     state = r->upstream_states->elts;

  6092.     for ( ;; ) {

  6094.         if (data == 1) {
  6095.             ms = state[i].header_time;

  6097.         } else if (data == 2) {
  6098.             ms = state[i].connect_time;

  6100.         } else {
  6101.             ms = state[i].response_time;
  6102.         }

  6104.         if (ms != -1) {
  6105.             ms = ngx_max(ms, 0);
  6106.             p = ngx_sprintf(p, "%T.%03M", (time_t) ms / 1000, ms % 1000);

  6108.         } else {
  6109.             *p++ = '-';
  6110.         }

  6112.         if (++i == r->upstream_states->nelts) {
  6113.             break;
  6114.         }

  6116.         if (state[i].peer) {
  6117.             *p++ = ',';
  6118.             *p++ = ' ';

  6120.         } else {
  6121.             *p++ = ' ';
  6122.             *p++ = ':';
  6123.             *p++ = ' ';

  6125.             if (++i == r->upstream_states->nelts) {
  6126.                 break;
  6127.             }

  6129.             continue;
  6130.         }
  6131.     }

  6133.     v->len = p - v->data;

  6135.     return NGX_OK;
  6136. }


  6139. static ngx_int_t
  6140. ‌ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
  6141.     ngx_http_variable_value_t *v, uintptr_t data)
  6142. {
  6143.     u_char                     *p;
  6144.     size_t                      len;
  6145.     ngx_uint_t                  i;
  6146.     ngx_http_upstream_state_t  *state;

  6148.     v->valid = 1;
  6149.     v->no_cacheable = 0;
  6150.     v->not_found = 0;

  6152.     if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
  6153.         v->not_found = 1;
  6154.         return NGX_OK;
  6155.     }

  6157.     len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);

  6159.     p = ngx_pnalloc(r->pool, len);
  6160.     if (p == NULL) {
  6161.         return NGX_ERROR;
  6162.     }

  6164.     v->data = p;

  6166.     i = 0;
  6167.     state = r->upstream_states->elts;

  6169.     for ( ;; ) {

  6171.         if (data == 1) {
  6172.             p = ngx_sprintf(p, "%O", state[i].bytes_received);

  6174.         } else if (data == 2) {
  6175.             p = ngx_sprintf(p, "%O", state[i].bytes_sent);

  6177.         } else {
  6178.             p = ngx_sprintf(p, "%O", state[i].response_length);
  6179.         }

  6181.         if (++i == r->upstream_states->nelts) {
  6182.             break;
  6183.         }

  6185.         if (state[i].peer) {
  6186.             *p++ = ',';
  6187.             *p++ = ' ';

  6189.         } else {
  6190.             *p++ = ' ';
  6191.             *p++ = ':';
  6192.             *p++ = ' ';

  6194.             if (++i == r->upstream_states->nelts) {
  6195.                 break;
  6196.             }

  6198.             continue;
  6199.         }
  6200.     }

  6202.     v->len = p - v->data;

  6204.     return NGX_OK;
  6205. }


  6208. static ngx_int_t
  6209. ‌ngx_http_upstream_header_variable(ngx_http_request_t *r,
  6210.     ngx_http_variable_value_t *v, uintptr_t data)
  6211. {
  6212.     if (r->upstream == NULL) {
  6213.         v->not_found = 1;
  6214.         return NGX_OK;
  6215.     }

  6217.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  6218.                                          &r->upstream->headers_in.headers.part,
  6219.                                          sizeof("upstream_http_") - 1);
  6220. }


  6223. static ngx_int_t
  6224. ‌ngx_http_upstream_trailer_variable(ngx_http_request_t *r,
  6225.     ngx_http_variable_value_t *v, uintptr_t data)
  6226. {
  6227.     if (r->upstream == NULL) {
  6228.         v->not_found = 1;
  6229.         return NGX_OK;
  6230.     }

  6232.     return ngx_http_variable_unknown_header(r, v, (ngx_str_t *) data,
  6233.                                         &r->upstream->headers_in.trailers.part,
  6234.                                         sizeof("upstream_trailer_") - 1);
  6235. }


  6238. static ngx_int_t
  6239. ‌ngx_http_upstream_cookie_variable(ngx_http_request_t *r,
  6240.     ngx_http_variable_value_t *v, uintptr_t data)
  6241. {
  6242.     ngx_str_t  *name = (ngx_str_t *) data;

  6244.     ngx_str_t   cookie, s;

  6246.     if (r->upstream == NULL) {
  6247.         v->not_found = 1;
  6248.         return NGX_OK;
  6249.     }

  6251.     s.len = name->len - (sizeof("upstream_cookie_") - 1);
  6252.     s.data = name->data + sizeof("upstream_cookie_") - 1;

  6254.     if (ngx_http_parse_set_cookie_lines(r, r->upstream->headers_in.set_cookie,
  6255.                                         &s, &cookie)
  6256.         == NULL)
  6257.     {
  6258.         v->not_found = 1;
  6259.         return NGX_OK;
  6260.     }

  6262.     v->len = cookie.len;
  6263.     v->valid = 1;
  6264.     v->no_cacheable = 0;
  6265.     v->not_found = 0;
  6266.     v->data = cookie.data;

  6268.     return NGX_OK;
  6269. }


  6272. #if (NGX_HTTP_CACHE)

  6274. static ngx_int_t
  6275. ‌ngx_http_upstream_cache_status(ngx_http_request_t *r,
  6276.     ngx_http_variable_value_t *v, uintptr_t data)
  6277. {
  6278.     ngx_uint_t  n;

  6280.     if (r->upstream == NULL || r->upstream->cache_status == 0) {
  6281.         v->not_found = 1;
  6282.         return NGX_OK;
  6283.     }

  6285.     n = r->upstream->cache_status - 1;

  6287.     v->valid = 1;
  6288.     v->no_cacheable = 0;
  6289.     v->not_found = 0;
  6290.     v->len = ngx_http_cache_status[n].len;
  6291.     v->data = ngx_http_cache_status[n].data;

  6293.     return NGX_OK;
  6294. }


  6297. static ngx_int_t
  6298. ‌ngx_http_upstream_cache_last_modified(ngx_http_request_t *r,
  6299.     ngx_http_variable_value_t *v, uintptr_t data)
  6300. {
  6301.     u_char  *p;

  6303.     if (r->upstream == NULL
  6304.         || !r->upstream->conf->cache_revalidate
  6305.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6306.         || r->cache->last_modified == -1)
  6307.     {
  6308.         v->not_found = 1;
  6309.         return NGX_OK;
  6310.     }

  6312.     p = ngx_pnalloc(r->pool, sizeof("Mon, 28 Sep 1970 06:00:00 GMT") - 1);
  6313.     if (p == NULL) {
  6314.         return NGX_ERROR;
  6315.     }

  6317.     v->len = ngx_http_time(p, r->cache->last_modified) - p;
  6318.     v->valid = 1;
  6319.     v->no_cacheable = 0;
  6320.     v->not_found = 0;
  6321.     v->data = p;

  6323.     return NGX_OK;
  6324. }


  6327. static ngx_int_t
  6328. ‌ngx_http_upstream_cache_etag(ngx_http_request_t *r,
  6329.     ngx_http_variable_value_t *v, uintptr_t data)
  6330. {
  6331.     if (r->upstream == NULL
  6332.         || !r->upstream->conf->cache_revalidate
  6333.         || r->upstream->cache_status != NGX_HTTP_CACHE_EXPIRED
  6334.         || r->cache->etag.len == 0)
  6335.     {
  6336.         v->not_found = 1;
  6337.         return NGX_OK;
  6338.     }

  6340.     v->valid = 1;
  6341.     v->no_cacheable = 0;
  6342.     v->not_found = 0;
  6343.     v->len = r->cache->etag.len;
  6344.     v->data = r->cache->etag.data;

  6346.     return NGX_OK;
  6347. }

  6349. #endif


  6352. static char *
  6353. ‌ngx_http_upstream(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
  6354. {
  6355.     char                          *rv;
  6356.     void                          *mconf;
  6357.     ngx_str_t                     *value;
  6358.     ngx_url_t                      u;
  6359.     ngx_uint_t                     m;
  6360.     ngx_conf_t                     pcf;
  6361.     ngx_http_module_t             *module;
  6362.     ngx_http_conf_ctx_t           *ctx, *http_ctx;
  6363.     ngx_http_upstream_srv_conf_t  *uscf;

  6365.     ngx_memzero(&u, sizeof(ngx_url_t));

  6367.     value = cf->args->elts;
  6368.     u.host = value[1];
  6369.     u.no_resolve = 1;
  6370.     u.no_port = 1;

  6372.     uscf = ngx_http_upstream_add(cf, &u, NGX_HTTP_UPSTREAM_CREATE
  6373.                                          |NGX_HTTP_UPSTREAM_MODIFY
  6374.                                          |NGX_HTTP_UPSTREAM_WEIGHT
  6375.                                          |NGX_HTTP_UPSTREAM_MAX_CONNS
  6376.                                          |NGX_HTTP_UPSTREAM_MAX_FAILS
  6377.                                          |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  6378.                                          |NGX_HTTP_UPSTREAM_DOWN
  6379.                                          |NGX_HTTP_UPSTREAM_BACKUP);
  6380.     if (uscf == NULL) {
  6381.         return NGX_CONF_ERROR;
  6382.     }


  6385.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  6386.     if (ctx == NULL) {
  6387.         return NGX_CONF_ERROR;
  6388.     }

  6390.     http_ctx = cf->ctx;
  6391.     ctx->main_conf = http_ctx->main_conf;

  6393.     /* the upstream{}'s srv_conf */

  6395.     ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6396.     if (ctx->srv_conf == NULL) {
  6397.         return NGX_CONF_ERROR;
  6398.     }

  6400.     ctx->srv_conf[ngx_http_upstream_module.ctx_index] = uscf;

  6402.     uscf->srv_conf = ctx->srv_conf;


  6405.     /* the upstream{}'s loc_conf */

  6407.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  6408.     if (ctx->loc_conf == NULL) {
  6409.         return NGX_CONF_ERROR;
  6410.     }

  6412.     for (m = 0; cf->cycle->modules[m]; m++) {
  6413.         if (cf->cycle->modules[m]->type != NGX_HTTP_MODULE) {
  6414.             continue;
  6415.         }

  6417.         module = cf->cycle->modules[m]->ctx;

  6419.         if (module->create_srv_conf) {
  6420.             mconf = module->create_srv_conf(cf);
  6421.             if (mconf == NULL) {
  6422.                 return NGX_CONF_ERROR;
  6423.             }

  6425.             ctx->srv_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6426.         }

  6428.         if (module->create_loc_conf) {
  6429.             mconf = module->create_loc_conf(cf);
  6430.             if (mconf == NULL) {
  6431.                 return NGX_CONF_ERROR;
  6432.             }

  6434.             ctx->loc_conf[cf->cycle->modules[m]->ctx_index] = mconf;
  6435.         }
  6436.     }

  6438.     uscf->servers = ngx_array_create(cf->pool, 4,
  6439.                                      sizeof(ngx_http_upstream_server_t));
  6440.     if (uscf->servers == NULL) {
  6441.         return NGX_CONF_ERROR;
  6442.     }


  6445.     /* parse inside upstream{} */

  6447.     pcf = *cf;
  6448.     cf->ctx = ctx;
  6449.     cf->cmd_type = NGX_HTTP_UPS_CONF;

  6451.     rv = ngx_conf_parse(cf, NULL);

  6453.     *cf = pcf;

  6455.     if (rv != NGX_CONF_OK) {
  6456.         return rv;
  6457.     }

  6459.     if (uscf->servers->nelts == 0) {
  6460.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6461.                            "no servers are inside upstream");
  6462.         return NGX_CONF_ERROR;
  6463.     }

  6465.     return rv;
  6466. }


  6469. static char *
  6470. ‌ngx_http_upstream_server(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6471. {
  6472.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6474.     time_t                       fail_timeout;
  6475.     ngx_str_t                   *value, s;
  6476.     ngx_url_t                    u;
  6477.     ngx_int_t                    weight, max_conns, max_fails;
  6478.     ngx_uint_t                   i;
  6479. #if (NGX_HTTP_UPSTREAM_ZONE)
  6480.     ngx_uint_t                   resolve;
  6481. #endif
  6482.     ngx_http_upstream_server_t  *us;

  6484.     us = ngx_array_push(uscf->servers);
  6485.     if (us == NULL) {
  6486.         return NGX_CONF_ERROR;
  6487.     }

  6489.     ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6491.     value = cf->args->elts;

  6493.     weight = 1;
  6494.     max_conns = 0;
  6495.     max_fails = 1;
  6496.     fail_timeout = 10;
  6497. #if (NGX_HTTP_UPSTREAM_ZONE)
  6498.     resolve = 0;
  6499. #endif

  6501.     for (i = 2; i < cf->args->nelts; i++) {

  6503.         if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {

  6505.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_WEIGHT)) {
  6506.                 goto not_supported;
  6507.             }

  6509.             weight = ngx_atoi(&value[i].data[7], value[i].len - 7);

  6511.             if (weight == NGX_ERROR || weight == 0) {
  6512.                 goto invalid;
  6513.             }

  6515.             continue;
  6516.         }

  6518.         if (ngx_strncmp(value[i].data, "max_conns=", 10) == 0) {

  6520.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_CONNS)) {
  6521.                 goto not_supported;
  6522.             }

  6524.             max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6526.             if (max_conns == NGX_ERROR) {
  6527.                 goto invalid;
  6528.             }

  6530.             continue;
  6531.         }

  6533.         if (ngx_strncmp(value[i].data, "max_fails=", 10) == 0) {

  6535.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_MAX_FAILS)) {
  6536.                 goto not_supported;
  6537.             }

  6539.             max_fails = ngx_atoi(&value[i].data[10], value[i].len - 10);

  6541.             if (max_fails == NGX_ERROR) {
  6542.                 goto invalid;
  6543.             }

  6545.             continue;
  6546.         }

  6548.         if (ngx_strncmp(value[i].data, "fail_timeout=", 13) == 0) {

  6550.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_FAIL_TIMEOUT)) {
  6551.                 goto not_supported;
  6552.             }

  6554.             s.len = value[i].len - 13;
  6555.             s.data = &value[i].data[13];

  6557.             fail_timeout = ngx_parse_time(&s, 1);

  6559.             if (fail_timeout == (time_t) NGX_ERROR) {
  6560.                 goto invalid;
  6561.             }

  6563.             continue;
  6564.         }

  6566.         if (ngx_strcmp(value[i].data, "backup") == 0) {

  6568.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_BACKUP)) {
  6569.                 goto not_supported;
  6570.             }

  6572.             us->backup = 1;

  6574.             continue;
  6575.         }

  6577.         if (ngx_strcmp(value[i].data, "down") == 0) {

  6579.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6580.                 goto not_supported;
  6581.             }

  6583.             us->down = NGX_HTTP_UPSTREAM_FAILED;

  6585.             continue;
  6586.         }

  6588. #if (NGX_HTTP_UPSTREAM_STICKY)
  6589.         if (ngx_strcmp(value[i].data, "drain") == 0) {

  6591.             if (!(uscf->flags & NGX_HTTP_UPSTREAM_DOWN)) {
  6592.                 goto not_supported;
  6593.             }

  6595.             us->down = NGX_HTTP_UPSTREAM_DRAINING;

  6597.             continue;
  6598.         }
  6599. #endif

  6601. #if (NGX_HTTP_UPSTREAM_SID)
  6602.         if (ngx_strncmp(value[i].data, "route=", 6) == 0) {

  6604.             us->sid.data = &value[i].data[6];
  6605.             us->sid.len = value[i].len - 6;

  6607.             if (us->sid.len == 0) {
  6608.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "route is empty");
  6609.                 return NGX_CONF_ERROR;
  6610.             }

  6612.             if (us->sid.len > NGX_HTTP_UPSTREAM_SID_LEN) {
  6613.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6614.                                    "route is longer than %d",
  6615.                                    NGX_HTTP_UPSTREAM_SID_LEN);
  6616.                 return NGX_CONF_ERROR;
  6617.             }

  6619.             continue;
  6620.         }
  6621. #endif

  6623. #if (NGX_HTTP_UPSTREAM_ZONE)
  6624.         if (ngx_strcmp(value[i].data, "resolve") == 0) {
  6625.             resolve = 1;
  6626.             continue;
  6627.         }

  6629.         if (ngx_strncmp(value[i].data, "service=", 8) == 0) {

  6631.             us->service.len = value[i].len - 8;
  6632.             us->service.data = &value[i].data[8];

  6634.             if (us->service.len == 0) {
  6635.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "service is empty");
  6636.                 return NGX_CONF_ERROR;
  6637.             }

  6639.             continue;
  6640.         }
  6641. #endif

  6643.         goto invalid;
  6644.     }

  6646.     ngx_memzero(&u, sizeof(ngx_url_t));

  6648.     u.url = value[1];
  6649.     u.default_port = 80;

  6651. #if (NGX_HTTP_UPSTREAM_ZONE)
  6652.     if (resolve) {
  6653.         /* resolve at run time */
  6654.         u.no_resolve = 1;
  6655.     }

  6657.     if (us->service.len && !resolve) {
  6658.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6659.                            "service upstream \"%V\" requires "
  6660.                            "\"resolve\" parameter",
  6661.                            &u.url);
  6662.         return NGX_CONF_ERROR;
  6663.     }

  6665. #endif

  6667.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  6668.         if (u.err) {
  6669.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6670.                                "%s in upstream \"%V\"", u.err, &u.url);
  6671.         }

  6673.         return NGX_CONF_ERROR;
  6674.     }

  6676.     us->name = u.url;

  6678. #if (NGX_HTTP_UPSTREAM_ZONE)

  6680.     if (us->service.len && !u.no_port) {
  6681.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6682.                            "service upstream \"%V\" may not have port",
  6683.                            &us->name);

  6685.         return NGX_CONF_ERROR;
  6686.     }

  6688.     if (us->service.len && u.naddrs) {
  6689.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6690.                            "service upstream \"%V\" requires domain name",
  6691.                            &us->name);

  6693.         return NGX_CONF_ERROR;
  6694.     }

  6696.     if (resolve && u.naddrs == 0) {
  6697.         ngx_addr_t  *addr;

  6699.         /* save port */

  6701.         addr = ngx_pcalloc(cf->pool, sizeof(ngx_addr_t));
  6702.         if (addr == NULL) {
  6703.             return NGX_CONF_ERROR;
  6704.         }

  6706.         addr->sockaddr = ngx_palloc(cf->pool, u.socklen);
  6707.         if (addr->sockaddr == NULL) {
  6708.             return NGX_CONF_ERROR;
  6709.         }

  6711.         ngx_memcpy(addr->sockaddr, &u.sockaddr, u.socklen);

  6713.         addr->socklen = u.socklen;

  6715.         us->addrs = addr;
  6716.         us->naddrs = 1;

  6718.         us->host = u.host;

  6720.     } else {
  6721.         us->addrs = u.addrs;
  6722.         us->naddrs = u.naddrs;
  6723.     }

  6725. #else

  6727.     us->addrs = u.addrs;
  6728.     us->naddrs = u.naddrs;

  6730. #endif

  6732.     us->weight = weight;
  6733.     us->max_conns = max_conns;
  6734.     us->max_fails = max_fails;
  6735.     us->fail_timeout = fail_timeout;

  6737.     return NGX_CONF_OK;

  6739. invalid:

  6741.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6742.                        "invalid parameter \"%V\"", &value[i]);

  6744.     return NGX_CONF_ERROR;

  6746. not_supported:

  6748.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6749.                        "balancing method does not support parameter \"%V\"",
  6750.                        &value[i]);

  6752.     return NGX_CONF_ERROR;
  6753. }


  6756. #if (NGX_HTTP_UPSTREAM_ZONE)

  6758. static char *
  6759. ‌ngx_http_upstream_resolver(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  6760. {
  6761.     ngx_http_upstream_srv_conf_t  *uscf = conf;

  6763.     ngx_str_t  *value;

  6765.     if (uscf->resolver) {
  6766.         return "is duplicate";
  6767.     }

  6769.     value = cf->args->elts;

  6771.     uscf->resolver = ngx_resolver_create(cf, &value[1], cf->args->nelts - 1);
  6772.     if (uscf->resolver == NULL) {
  6773.         return NGX_CONF_ERROR;
  6774.     }

  6776.     return NGX_CONF_OK;
  6777. }

  6779. #endif


  6782. ngx_http_upstream_srv_conf_t *
  6783. ‌ngx_http_upstream_add(ngx_conf_t *cf, ngx_url_t *u, ngx_uint_t flags)
  6784. {
  6785.     ngx_uint_t                      i;
  6786.     ngx_http_upstream_server_t     *us;
  6787.     ngx_http_upstream_srv_conf_t   *uscf, **uscfp;
  6788.     ngx_http_upstream_main_conf_t  *umcf;

  6790.     if (!(flags & NGX_HTTP_UPSTREAM_CREATE)) {

  6792.         if (ngx_parse_url(cf->pool, u) != NGX_OK) {
  6793.             if (u->err) {
  6794.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6795.                                    "%s in upstream \"%V\"", u->err, &u->url);
  6796.             }

  6798.             return NULL;
  6799.         }
  6800.     }

  6802.     umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);

  6804.     uscfp = umcf->upstreams.elts;

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

  6808.         if (uscfp[i]->host.len != u->host.len
  6809.             || ngx_strncasecmp(uscfp[i]->host.data, u->host.data, u->host.len)
  6810.                != 0)
  6811.         {
  6812.             continue;
  6813.         }

  6815.         if ((flags & NGX_HTTP_UPSTREAM_CREATE)
  6816.              && (uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE))
  6817.         {
  6818.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6819.                                "duplicate upstream \"%V\"", &u->host);
  6820.             return NULL;
  6821.         }

  6823.         if ((uscfp[i]->flags & NGX_HTTP_UPSTREAM_CREATE) && !u->no_port) {
  6824.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6825.                                "upstream \"%V\" may not have port %d",
  6826.                                &u->host, u->port);
  6827.             return NULL;
  6828.         }

  6830.         if ((flags & NGX_HTTP_UPSTREAM_CREATE) && !uscfp[i]->no_port) {
  6831.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  6832.                           "upstream \"%V\" may not have port %d in %s:%ui",
  6833.                           &u->host, uscfp[i]->port,
  6834.                           uscfp[i]->file_name, uscfp[i]->line);
  6835.             return NULL;
  6836.         }

  6838.         if (uscfp[i]->port && u->port
  6839.             && uscfp[i]->port != u->port)
  6840.         {
  6841.             continue;
  6842.         }

  6844.         if (flags & NGX_HTTP_UPSTREAM_CREATE) {
  6845.             uscfp[i]->flags = flags;
  6846.             uscfp[i]->port = 0;
  6847.         }

  6849.         return uscfp[i];
  6850.     }

  6852.     uscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
  6853.     if (uscf == NULL) {
  6854.         return NULL;
  6855.     }

  6857.     uscf->flags = flags;
  6858.     uscf->host = u->host;
  6859.     uscf->file_name = cf->conf_file->file.name.data;
  6860.     uscf->line = cf->conf_file->line;
  6861.     uscf->port = u->port;
  6862.     uscf->no_port = u->no_port;
  6863. #if (NGX_HTTP_UPSTREAM_ZONE)
  6864.     uscf->resolver_timeout = NGX_CONF_UNSET_MSEC;
  6865. #endif

  6867.     if (u->naddrs == 1 && (u->port || u->family == AF_UNIX)) {
  6868.         uscf->servers = ngx_array_create(cf->pool, 1,
  6869.                                          sizeof(ngx_http_upstream_server_t));
  6870.         if (uscf->servers == NULL) {
  6871.             return NULL;
  6872.         }

  6874.         us = ngx_array_push(uscf->servers);
  6875.         if (us == NULL) {
  6876.             return NULL;
  6877.         }

  6879.         ngx_memzero(us, sizeof(ngx_http_upstream_server_t));

  6881.         us->addrs = u->addrs;
  6882.         us->naddrs = 1;
  6883.     }

  6885.     uscfp = ngx_array_push(&umcf->upstreams);
  6886.     if (uscfp == NULL) {
  6887.         return NULL;
  6888.     }

  6890.     *uscfp = uscf;

  6892.     return uscf;
  6893. }


  6896. char *
  6897. ‌ngx_http_upstream_bind_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  6898.     void *conf)
  6899. {
  6900.     char  *p = conf;

  6902.     ngx_int_t                           rc;
  6903.     ngx_str_t                          *value;
  6904.     ngx_http_complex_value_t            cv;
  6905.     ngx_http_upstream_local_t         **plocal, *local;
  6906.     ngx_http_compile_complex_value_t    ccv;

  6908.     plocal = (ngx_http_upstream_local_t **) (p + cmd->offset);

  6910.     if (*plocal != NGX_CONF_UNSET_PTR) {
  6911.         return "is duplicate";
  6912.     }

  6914.     value = cf->args->elts;

  6916.     if (cf->args->nelts == 2 && ngx_strcmp(value[1].data, "off") == 0) {
  6917.         *plocal = NULL;
  6918.         return NGX_CONF_OK;
  6919.     }

  6921.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  6923.     ccv.cf = cf;
  6924.     ccv.value = &value[1];
  6925.     ccv.complex_value = &cv;

  6927.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  6928.         return NGX_CONF_ERROR;
  6929.     }

  6931.     local = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_local_t));
  6932.     if (local == NULL) {
  6933.         return NGX_CONF_ERROR;
  6934.     }

  6936.     *plocal = local;

  6938.     if (cv.lengths) {
  6939.         local->value = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  6940.         if (local->value == NULL) {
  6941.             return NGX_CONF_ERROR;
  6942.         }

  6944.         *local->value = cv;

  6946.     } else {
  6947.         local->addr = ngx_palloc(cf->pool, sizeof(ngx_addr_t));
  6948.         if (local->addr == NULL) {
  6949.             return NGX_CONF_ERROR;
  6950.         }

  6952.         rc = ngx_parse_addr_port(cf->pool, local->addr, value[1].data,
  6953.                                  value[1].len);

  6955.         switch (rc) {
  6956.         case NGX_OK:
  6957.             local->addr->name = value[1];
  6958.             break;

  6960.         case NGX_DECLINED:
  6961.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6962.                                "invalid address \"%V\"", &value[1]);
  6963.             /* fall through */

  6965.         default:
  6966.             return NGX_CONF_ERROR;
  6967.         }
  6968.     }

  6970.     if (cf->args->nelts > 2) {
  6971.         if (ngx_strcmp(value[2].data, "transparent") == 0) {
  6972. #if (NGX_HAVE_TRANSPARENT_PROXY)
  6973.             ngx_core_conf_t  *ccf;

  6975.             ccf = (ngx_core_conf_t *) ngx_get_conf(cf->cycle->conf_ctx,
  6976.                                                    ngx_core_module);

  6978.             ccf->transparent = 1;
  6979.             local->transparent = 1;
  6980. #else
  6981.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6982.                                "transparent proxying is not supported "
  6983.                                "on this platform, ignored");
  6984. #endif
  6985.         } else {
  6986.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  6987.                                "invalid parameter \"%V\"", &value[2]);
  6988.             return NGX_CONF_ERROR;
  6989.         }
  6990.     }

  6992.     return NGX_CONF_OK;
  6993. }


  6996. static ngx_int_t
  6997. ‌ngx_http_upstream_set_local(ngx_http_request_t *r, ngx_http_upstream_t *u,
  6998.     ngx_http_upstream_local_t *local)
  6999. {
  7000.     ngx_int_t    rc;
  7001.     ngx_str_t    val;
  7002.     ngx_addr_t  *addr;

  7004.     if (local == NULL) {
  7005.         u->peer.local = NULL;
  7006.         return NGX_OK;
  7007.     }

  7009. #if (NGX_HAVE_TRANSPARENT_PROXY)
  7010.     u->peer.transparent = local->transparent;
  7011. #endif

  7013.     if (local->value == NULL) {
  7014.         u->peer.local = local->addr;
  7015.         return NGX_OK;
  7016.     }

  7018.     if (ngx_http_complex_value(r, local->value, &val) != NGX_OK) {
  7019.         return NGX_ERROR;
  7020.     }

  7022.     if (val.len == 0) {
  7023.         u->peer.local = NULL;
  7024.         return NGX_OK;
  7025.     }

  7027.     addr = ngx_palloc(r->pool, sizeof(ngx_addr_t));
  7028.     if (addr == NULL) {
  7029.         return NGX_ERROR;
  7030.     }

  7032.     rc = ngx_parse_addr_port(r->pool, addr, val.data, val.len);
  7033.     if (rc == NGX_ERROR) {
  7034.         return NGX_ERROR;
  7035.     }

  7037.     if (rc != NGX_OK) {
  7038.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  7039.                       "invalid local address \"%V\"", &val);
  7040.         u->peer.local = NULL;
  7041.         return NGX_OK;
  7042.     }

  7044.     addr->name = val;
  7045.     u->peer.local = addr;

  7047.     return NGX_OK;
  7048. }


  7051. char *
  7052. ‌ngx_http_upstream_param_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  7053.     void *conf)
  7054. {
  7055.     char  *p = conf;

  7057.     ngx_str_t                   *value;
  7058.     ngx_array_t                **a;
  7059.     ngx_http_upstream_param_t   *param;

  7061.     a = (ngx_array_t **) (p + cmd->offset);

  7063.     if (*a == NULL) {
  7064.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_http_upstream_param_t));
  7065.         if (*a == NULL) {
  7066.             return NGX_CONF_ERROR;
  7067.         }
  7068.     }

  7070.     param = ngx_array_push(*a);
  7071.     if (param == NULL) {
  7072.         return NGX_CONF_ERROR;
  7073.     }

  7075.     value = cf->args->elts;

  7077.     param->key = value[1];
  7078.     param->value = value[2];
  7079.     param->skip_empty = 0;

  7081.     if (cf->args->nelts == 4) {
  7082.         if (ngx_strcmp(value[3].data, "if_not_empty") != 0) {
  7083.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  7084.                                "invalid parameter \"%V\"", &value[3]);
  7085.             return NGX_CONF_ERROR;
  7086.         }

  7088.         param->skip_empty = 1;
  7089.     }

  7091.     return NGX_CONF_OK;
  7092. }


  7095. ngx_int_t
  7096. ‌ngx_http_upstream_hide_headers_hash(ngx_conf_t *cf,
  7097.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev,
  7098.     ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
  7099. {
  7100.     ngx_str_t       *h;
  7101.     ngx_uint_t       i, j;
  7102.     ngx_array_t      hide_headers;
  7103.     ngx_hash_key_t  *hk;

  7105.     if (conf->hide_headers == NGX_CONF_UNSET_PTR
  7106.         && conf->pass_headers == NGX_CONF_UNSET_PTR)
  7107.     {
  7108.         conf->hide_headers = prev->hide_headers;
  7109.         conf->pass_headers = prev->pass_headers;

  7111.         conf->hide_headers_hash = prev->hide_headers_hash;

  7113.         if (conf->hide_headers_hash.buckets) {
  7114.             return NGX_OK;
  7115.         }

  7117.     } else {
  7118.         if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
  7119.             conf->hide_headers = prev->hide_headers;
  7120.         }

  7122.         if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
  7123.             conf->pass_headers = prev->pass_headers;
  7124.         }
  7125.     }

  7127.     if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  7128.         != NGX_OK)
  7129.     {
  7130.         return NGX_ERROR;
  7131.     }

  7133.     for (h = default_hide_headers; h->len; h++) {
  7134.         hk = ngx_array_push(&hide_headers);
  7135.         if (hk == NULL) {
  7136.             return NGX_ERROR;
  7137.         }

  7139.         hk->key = *h;
  7140.         hk->key_hash = ngx_hash_key_lc(h->data, h->len);
  7141.         hk->value = (void *) 1;
  7142.     }

  7144.     if (conf->hide_headers != NGX_CONF_UNSET_PTR) {

  7146.         h = conf->hide_headers->elts;

  7148.         for (i = 0; i < conf->hide_headers->nelts; i++) {

  7150.             hk = hide_headers.elts;

  7152.             for (j = 0; j < hide_headers.nelts; j++) {
  7153.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  7154.                     goto exist;
  7155.                 }
  7156.             }

  7158.             hk = ngx_array_push(&hide_headers);
  7159.             if (hk == NULL) {
  7160.                 return NGX_ERROR;
  7161.             }

  7163.             hk->key = h[i];
  7164.             hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
  7165.             hk->value = (void *) 1;

  7167.         exist:

  7169.             continue;
  7170.         }
  7171.     }

  7173.     if (conf->pass_headers != NGX_CONF_UNSET_PTR) {

  7175.         h = conf->pass_headers->elts;
  7176.         hk = hide_headers.elts;

  7178.         for (i = 0; i < conf->pass_headers->nelts; i++) {
  7179.             for (j = 0; j < hide_headers.nelts; j++) {

  7181.                 if (hk[j].key.data == NULL) {
  7182.                     continue;
  7183.                 }

  7185.                 if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
  7186.                     hk[j].key.data = NULL;
  7187.                     break;
  7188.                 }
  7189.             }
  7190.         }
  7191.     }

  7193.     hash->hash = &conf->hide_headers_hash;
  7194.     hash->key = ngx_hash_key_lc;
  7195.     hash->pool = cf->pool;
  7196.     hash->temp_pool = NULL;

  7198.     if (ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts) != NGX_OK) {
  7199.         return NGX_ERROR;
  7200.     }

  7202.     /*
  7203.      * special handling to preserve conf->hide_headers_hash
  7204.      * in the "http" section to inherit it to all servers
  7205.      */

  7207.     if (prev->hide_headers_hash.buckets == NULL
  7208.         && conf->hide_headers == prev->hide_headers
  7209.         && conf->pass_headers == prev->pass_headers)
  7210.     {
  7211.         prev->hide_headers_hash = conf->hide_headers_hash;
  7212.     }

  7214.     return NGX_OK;
  7215. }


  7218. #if (NGX_HTTP_SSL)

  7220. ngx_int_t
  7221. ‌ngx_http_upstream_merge_ssl_passwords(ngx_conf_t *cf,
  7222.     ngx_http_upstream_conf_t *conf, ngx_http_upstream_conf_t *prev)
  7223. {
  7224.     ngx_uint_t  preserve;

  7226.     ngx_conf_merge_ptr_value(conf->ssl_passwords, prev->ssl_passwords, NULL);

  7228.     if (conf->ssl_certificate == NULL
  7229.         || conf->ssl_certificate->value.len == 0
  7230.         || conf->ssl_certificate_key == NULL)
  7231.     {
  7232.         return NGX_OK;
  7233.     }

  7235.     if (conf->ssl_certificate->lengths == NULL
  7236.         && conf->ssl_certificate_key->lengths == NULL)
  7237.     {
  7238.         if (conf->ssl_passwords && conf->ssl_passwords->pool == NULL) {
  7239.             /* un-preserve empty password list */
  7240.             conf->ssl_passwords = NULL;
  7241.         }

  7243.         return NGX_OK;
  7244.     }

  7246.     if (conf->ssl_passwords && conf->ssl_passwords->pool != cf->temp_pool) {
  7247.         /* already preserved */
  7248.         return NGX_OK;
  7249.     }

  7251.     preserve = (conf->ssl_passwords == prev->ssl_passwords) ? 1 : 0;

  7253.     conf->ssl_passwords = ngx_ssl_preserve_passwords(cf, conf->ssl_passwords);
  7254.     if (conf->ssl_passwords == NULL) {
  7255.         return NGX_ERROR;
  7256.     }

  7258.     /*
  7259.      * special handling to keep a preserved ssl_passwords copy
  7260.      * in the previous configuration to inherit it to all children
  7261.      */

  7263.     if (preserve) {
  7264.         prev->ssl_passwords = conf->ssl_passwords;
  7265.     }

  7267.     return NGX_OK;
  7268. }

  7270. #endif


  7273. static void *
  7274. ‌ngx_http_upstream_create_main_conf(ngx_conf_t *cf)
  7275. {
  7276.     ngx_http_upstream_main_conf_t  *umcf;

  7278.     umcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_main_conf_t));
  7279.     if (umcf == NULL) {
  7280.         return NULL;
  7281.     }

  7283.     if (ngx_array_init(&umcf->upstreams, cf->pool, 4,
  7284.                        sizeof(ngx_http_upstream_srv_conf_t *))
  7285.         != NGX_OK)
  7286.     {
  7287.         return NULL;
  7288.     }

  7290.     return umcf;
  7291. }


  7294. static char *
  7295. ‌ngx_http_upstream_init_main_conf(ngx_conf_t *cf, void *conf)
  7296. {
  7297.     ngx_http_upstream_main_conf_t  *umcf = conf;

  7299.     ngx_uint_t                      i;
  7300.     ngx_array_t                     headers_in;
  7301.     ngx_hash_key_t                 *hk;
  7302.     ngx_hash_init_t                 hash;
  7303.     ngx_http_upstream_init_pt       init;
  7304.     ngx_http_upstream_header_t     *header;
  7305.     ngx_http_upstream_srv_conf_t  **uscfp;

  7307.     uscfp = umcf->upstreams.elts;

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

  7311.         init = uscfp[i]->peer.init_upstream ? uscfp[i]->peer.init_upstream:
  7312.                                             ngx_http_upstream_init_round_robin;

  7314.         if (init(cf, uscfp[i]) != NGX_OK) {
  7315.             return NGX_CONF_ERROR;
  7316.         }
  7317.     }


  7320.     /* upstream_headers_in_hash */

  7322.     if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
  7323.         != NGX_OK)
  7324.     {
  7325.         return NGX_CONF_ERROR;
  7326.     }

  7328.     for (header = ngx_http_upstream_headers_in; header->name.len; header++) {
  7329.         hk = ngx_array_push(&headers_in);
  7330.         if (hk == NULL) {
  7331.             return NGX_CONF_ERROR;
  7332.         }

  7334.         hk->key = header->name;
  7335.         hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
  7336.         hk->value = header;
  7337.     }

  7339.     hash.hash = &umcf->headers_in_hash;
  7340.     hash.key = ngx_hash_key_lc;
  7341.     hash.max_size = 512;
  7342.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  7343.     hash.name = "upstream_headers_in_hash";
  7344.     hash.pool = cf->pool;
  7345.     hash.temp_pool = NULL;

  7347.     if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
  7348.         return NGX_CONF_ERROR;
  7349.     }

  7351.     return NGX_CONF_OK;
  7352. }

One Level Up Top Level