One Level Up Top Level

src/http/modules/ngx_http_fastcgi_module.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Data types defined

Functions defined

Macros 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. ‌typedef struct {
  14.     ngx_array_t                    caches;  /* ngx_http_file_cache_t * */
  15. ‌} ngx_http_fastcgi_main_conf_t;


  18. ‌typedef struct {
  19.     ngx_array_t                   *flushes;
  20.     ngx_array_t                   *lengths;
  21.     ngx_array_t                   *values;
  22.     ngx_uint_t                     number;
  23.     ngx_hash_t                     hash;
  24. ‌} ngx_http_fastcgi_params_t;


  27. ‌typedef struct {
  28.     ngx_http_upstream_conf_t       upstream;

  30.     ngx_str_t                      index;

  32.     ngx_http_fastcgi_params_t      params;
  33. #if (NGX_HTTP_CACHE)
  34.     ngx_http_fastcgi_params_t      params_cache;
  35. #endif

  37.     ngx_array_t                   *params_source;
  38.     ngx_array_t                   *catch_stderr;

  40.     ngx_array_t                   *fastcgi_lengths;
  41.     ngx_array_t                   *fastcgi_values;

  43.     ngx_flag_t                     keep_conn;

  45. #if (NGX_HTTP_CACHE)
  46.     ngx_http_complex_value_t       cache_key;
  47. #endif

  49. #if (NGX_PCRE)
  50.     ngx_regex_t                   *split_regex;
  51.     ngx_str_t                      split_name;
  52. #endif
  53. ‌} ngx_http_fastcgi_loc_conf_t;


  56. ‌typedef enum {
  57.     ngx_http_fastcgi_st_version = 0,
  58.     ngx_http_fastcgi_st_type,
  59.     ngx_http_fastcgi_st_request_id_hi,
  60.     ngx_http_fastcgi_st_request_id_lo,
  61.     ngx_http_fastcgi_st_content_length_hi,
  62.     ngx_http_fastcgi_st_content_length_lo,
  63.     ngx_http_fastcgi_st_padding_length,
  64.     ngx_http_fastcgi_st_reserved,
  65.     ngx_http_fastcgi_st_data,
  66.     ngx_http_fastcgi_st_padding
  67. ‌} ngx_http_fastcgi_state_e;


  70. ‌typedef struct {
  71.     u_char                        *start;
  72.     u_char                        *end;
  73. ‌} ngx_http_fastcgi_split_part_t;


  76. ‌typedef struct {
  77.     ngx_http_fastcgi_state_e       state;
  78.     u_char                        *pos;
  79.     u_char                        *last;
  80.     ngx_uint_t                     type;
  81.     size_t                         length;
  82.     size_t                         padding;

  84.     off_t                          rest;

  86.     ngx_chain_t                   *free;
  87.     ngx_chain_t                   *busy;

  89.     unsigned                       fastcgi_stdout:1;
  90.     unsigned                       large_stderr:1;
  91.     unsigned                       header_sent:1;
  92.     unsigned                       closed:1;

  94.     ngx_array_t                   *split_parts;

  96.     ngx_str_t                      script_name;
  97.     ngx_str_t                      path_info;
  98. ‌} ngx_http_fastcgi_ctx_t;


  101. ‌#define NGX_HTTP_FASTCGI_RESPONDER      1

  103. ‌#define NGX_HTTP_FASTCGI_KEEP_CONN      1

  105. ‌#define NGX_HTTP_FASTCGI_BEGIN_REQUEST  1
  106. ‌#define NGX_HTTP_FASTCGI_ABORT_REQUEST  2
  107. ‌#define NGX_HTTP_FASTCGI_END_REQUEST    3
  108. ‌#define NGX_HTTP_FASTCGI_PARAMS         4
  109. ‌#define NGX_HTTP_FASTCGI_STDIN          5
  110. ‌#define NGX_HTTP_FASTCGI_STDOUT         6
  111. ‌#define NGX_HTTP_FASTCGI_STDERR         7
  112. ‌#define NGX_HTTP_FASTCGI_DATA           8


  115. ‌typedef struct {
  116.     u_char  version;
  117.     u_char  type;
  118.     u_char  request_id_hi;
  119.     u_char  request_id_lo;
  120.     u_char  content_length_hi;
  121.     u_char  content_length_lo;
  122.     u_char  padding_length;
  123.     u_char  reserved;
  124. ‌} ngx_http_fastcgi_header_t;


  127. ‌typedef struct {
  128.     u_char  role_hi;
  129.     u_char  role_lo;
  130.     u_char  flags;
  131.     u_char  reserved[5];
  132. ‌} ngx_http_fastcgi_begin_request_t;


  135. ‌typedef struct {
  136.     u_char  version;
  137.     u_char  type;
  138.     u_char  request_id_hi;
  139.     u_char  request_id_lo;
  140. ‌} ngx_http_fastcgi_header_small_t;


  143. ‌typedef struct {
  144.     ngx_http_fastcgi_header_t         h0;
  145.     ngx_http_fastcgi_begin_request_t  br;
  146.     ngx_http_fastcgi_header_small_t   h1;
  147. ‌} ngx_http_fastcgi_request_start_t;


  150. static ngx_int_t ngx_http_fastcgi_eval(ngx_http_request_t *r,
  151.     ngx_http_fastcgi_loc_conf_t *flcf);
  152. #if (NGX_HTTP_CACHE)
  153. static ngx_int_t ngx_http_fastcgi_create_key(ngx_http_request_t *r);
  154. #endif
  155. static ngx_int_t ngx_http_fastcgi_create_request(ngx_http_request_t *r);
  156. static ngx_int_t ngx_http_fastcgi_reinit_request(ngx_http_request_t *r);
  157. static ngx_int_t ngx_http_fastcgi_body_output_filter(void *data,
  158.     ngx_chain_t *in);
  159. static ngx_int_t ngx_http_fastcgi_process_header(ngx_http_request_t *r);
  160. static ngx_int_t ngx_http_fastcgi_input_filter_init(void *data);
  161. static ngx_int_t ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p,
  162.     ngx_buf_t *buf);
  163. static ngx_int_t ngx_http_fastcgi_non_buffered_filter(void *data,
  164.     ssize_t bytes);
  165. static ngx_int_t ngx_http_fastcgi_process_record(ngx_http_request_t *r,
  166.     ngx_http_fastcgi_ctx_t *f);
  167. static void ngx_http_fastcgi_abort_request(ngx_http_request_t *r);
  168. static void ngx_http_fastcgi_finalize_request(ngx_http_request_t *r,
  169.     ngx_int_t rc);

  171. static ngx_int_t ngx_http_fastcgi_add_variables(ngx_conf_t *cf);
  172. static void *ngx_http_fastcgi_create_main_conf(ngx_conf_t *cf);
  173. static void *ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf);
  174. static char *ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf,
  175.     void *parent, void *child);
  176. static ngx_int_t ngx_http_fastcgi_init_params(ngx_conf_t *cf,
  177.     ngx_http_fastcgi_loc_conf_t *conf, ngx_http_fastcgi_params_t *params,
  178.     ngx_keyval_t *default_params);

  180. static ngx_int_t ngx_http_fastcgi_script_name_variable(ngx_http_request_t *r,
  181.     ngx_http_variable_value_t *v, uintptr_t data);
  182. static ngx_int_t ngx_http_fastcgi_path_info_variable(ngx_http_request_t *r,
  183.     ngx_http_variable_value_t *v, uintptr_t data);
  184. static ngx_http_fastcgi_ctx_t *ngx_http_fastcgi_split(ngx_http_request_t *r,
  185.     ngx_http_fastcgi_loc_conf_t *flcf);

  187. static char *ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd,
  188.     void *conf);
  189. static char *ngx_http_fastcgi_split_path_info(ngx_conf_t *cf,
  190.     ngx_command_t *cmd, void *conf);
  191. static char *ngx_http_fastcgi_store(ngx_conf_t *cf, ngx_command_t *cmd,
  192.     void *conf);
  193. #if (NGX_HTTP_CACHE)
  194. static char *ngx_http_fastcgi_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  195.     void *conf);
  196. static char *ngx_http_fastcgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd,
  197.     void *conf);
  198. #endif

  200. static char *ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post,
  201.     void *data);


  204. ‌static ngx_conf_post_t  ngx_http_fastcgi_lowat_post =
  205.     { ngx_http_fastcgi_lowat_check };


  208. ‌static ngx_conf_bitmask_t  ngx_http_fastcgi_next_upstream_masks[] = {
  209.     { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
  210.     { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
  211.     { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
  212.     { ngx_string("non_idempotent"), NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT },
  213.     { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  214.     { ngx_string("http_503"), NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  215.     { ngx_string("http_403"), NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  216.     { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  217.     { ngx_string("http_429"), NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  218.     { ngx_string("updating"), NGX_HTTP_UPSTREAM_FT_UPDATING },
  219.     { ngx_string("off"), NGX_HTTP_UPSTREAM_FT_OFF },
  220.     { ngx_null_string, 0 }
  221. };


  224. ‌ngx_module_t  ngx_http_fastcgi_module;


  227. ‌static ngx_command_t  ngx_http_fastcgi_commands[] = {

  229.     { ngx_string("fastcgi_pass"),
  230.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  231.       ngx_http_fastcgi_pass,
  232.       NGX_HTTP_LOC_CONF_OFFSET,
  233.       0,
  234.       NULL },

  236.     { ngx_string("fastcgi_index"),
  237.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  238.       ngx_conf_set_str_slot,
  239.       NGX_HTTP_LOC_CONF_OFFSET,
  240.       offsetof(ngx_http_fastcgi_loc_conf_t, index),
  241.       NULL },

  243.     { ngx_string("fastcgi_split_path_info"),
  244.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  245.       ngx_http_fastcgi_split_path_info,
  246.       NGX_HTTP_LOC_CONF_OFFSET,
  247.       0,
  248.       NULL },

  250.     { ngx_string("fastcgi_store"),
  251.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  252.       ngx_http_fastcgi_store,
  253.       NGX_HTTP_LOC_CONF_OFFSET,
  254.       0,
  255.       NULL },

  257.     { ngx_string("fastcgi_store_access"),
  258.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  259.       ngx_conf_set_access_slot,
  260.       NGX_HTTP_LOC_CONF_OFFSET,
  261.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.store_access),
  262.       NULL },

  264.     { ngx_string("fastcgi_buffering"),
  265.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  266.       ngx_conf_set_flag_slot,
  267.       NGX_HTTP_LOC_CONF_OFFSET,
  268.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.buffering),
  269.       NULL },

  271.     { ngx_string("fastcgi_request_buffering"),
  272.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  273.       ngx_conf_set_flag_slot,
  274.       NGX_HTTP_LOC_CONF_OFFSET,
  275.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.request_buffering),
  276.       NULL },

  278.     { ngx_string("fastcgi_ignore_client_abort"),
  279.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  280.       ngx_conf_set_flag_slot,
  281.       NGX_HTTP_LOC_CONF_OFFSET,
  282.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.ignore_client_abort),
  283.       NULL },

  285.     { ngx_string("fastcgi_bind"),
  286.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  287.       ngx_http_upstream_bind_set_slot,
  288.       NGX_HTTP_LOC_CONF_OFFSET,
  289.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.local),
  290.       NULL },

  292.     { ngx_string("fastcgi_socket_keepalive"),
  293.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  294.       ngx_conf_set_flag_slot,
  295.       NGX_HTTP_LOC_CONF_OFFSET,
  296.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.socket_keepalive),
  297.       NULL },

  299.     { ngx_string("fastcgi_socket_rcvbuf"),
  300.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  301.       ngx_conf_set_size_slot,
  302.       NGX_HTTP_LOC_CONF_OFFSET,
  303.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.socket_rcvbuf),
  304.       NULL },

  306.     { ngx_string("fastcgi_socket_sndbuf"),
  307.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  308.       ngx_conf_set_size_slot,
  309.       NGX_HTTP_LOC_CONF_OFFSET,
  310.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.socket_sndbuf),
  311.       NULL },

  313.     { ngx_string("fastcgi_connect_timeout"),
  314.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  315.       ngx_conf_set_msec_slot,
  316.       NGX_HTTP_LOC_CONF_OFFSET,
  317.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.connect_timeout),
  318.       NULL },

  320.     { ngx_string("fastcgi_send_timeout"),
  321.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  322.       ngx_conf_set_msec_slot,
  323.       NGX_HTTP_LOC_CONF_OFFSET,
  324.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.send_timeout),
  325.       NULL },

  327.     { ngx_string("fastcgi_send_lowat"),
  328.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  329.       ngx_conf_set_size_slot,
  330.       NGX_HTTP_LOC_CONF_OFFSET,
  331.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.send_lowat),
  332.       &ngx_http_fastcgi_lowat_post },

  334.     { ngx_string("fastcgi_buffer_size"),
  335.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  336.       ngx_conf_set_size_slot,
  337.       NGX_HTTP_LOC_CONF_OFFSET,
  338.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.buffer_size),
  339.       &ngx_conf_size_nonzero_post },

  341.     { ngx_string("fastcgi_pass_request_headers"),
  342.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  343.       ngx_conf_set_flag_slot,
  344.       NGX_HTTP_LOC_CONF_OFFSET,
  345.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.pass_request_headers),
  346.       NULL },

  348.     { ngx_string("fastcgi_pass_request_body"),
  349.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  350.       ngx_conf_set_flag_slot,
  351.       NGX_HTTP_LOC_CONF_OFFSET,
  352.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.pass_request_body),
  353.       NULL },

  355.     { ngx_string("fastcgi_intercept_errors"),
  356.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  357.       ngx_conf_set_flag_slot,
  358.       NGX_HTTP_LOC_CONF_OFFSET,
  359.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.intercept_errors),
  360.       NULL },

  362.     { ngx_string("fastcgi_read_timeout"),
  363.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  364.       ngx_conf_set_msec_slot,
  365.       NGX_HTTP_LOC_CONF_OFFSET,
  366.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.read_timeout),
  367.       NULL },

  369.     { ngx_string("fastcgi_buffers"),
  370.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  371.       ngx_conf_set_bufs_slot,
  372.       NGX_HTTP_LOC_CONF_OFFSET,
  373.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.bufs),
  374.       NULL },

  376.     { ngx_string("fastcgi_busy_buffers_size"),
  377.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  378.       ngx_conf_set_size_slot,
  379.       NGX_HTTP_LOC_CONF_OFFSET,
  380.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.busy_buffers_size_conf),
  381.       NULL },

  383.     { ngx_string("fastcgi_force_ranges"),
  384.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  385.       ngx_conf_set_flag_slot,
  386.       NGX_HTTP_LOC_CONF_OFFSET,
  387.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.force_ranges),
  388.       NULL },

  390.     { ngx_string("fastcgi_limit_rate"),
  391.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  392.       ngx_http_set_complex_value_size_slot,
  393.       NGX_HTTP_LOC_CONF_OFFSET,
  394.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.limit_rate),
  395.       NULL },

  397. #if (NGX_HTTP_CACHE)

  399.     { ngx_string("fastcgi_cache"),
  400.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  401.       ngx_http_fastcgi_cache,
  402.       NGX_HTTP_LOC_CONF_OFFSET,
  403.       0,
  404.       NULL },

  406.     { ngx_string("fastcgi_cache_key"),
  407.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  408.       ngx_http_fastcgi_cache_key,
  409.       NGX_HTTP_LOC_CONF_OFFSET,
  410.       0,
  411.       NULL },

  413.     { ngx_string("fastcgi_cache_path"),
  414.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  415.       ngx_http_file_cache_set_slot,
  416.       NGX_HTTP_MAIN_CONF_OFFSET,
  417.       offsetof(ngx_http_fastcgi_main_conf_t, caches),
  418.       &ngx_http_fastcgi_module },

  420.     { ngx_string("fastcgi_cache_bypass"),
  421.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  422.       ngx_http_set_predicate_slot,
  423.       NGX_HTTP_LOC_CONF_OFFSET,
  424.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_bypass),
  425.       NULL },

  427.     { ngx_string("fastcgi_no_cache"),
  428.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  429.       ngx_http_set_predicate_slot,
  430.       NGX_HTTP_LOC_CONF_OFFSET,
  431.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.no_cache),
  432.       NULL },

  434.     { ngx_string("fastcgi_cache_valid"),
  435.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  436.       ngx_http_file_cache_valid_set_slot,
  437.       NGX_HTTP_LOC_CONF_OFFSET,
  438.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_valid),
  439.       NULL },

  441.     { ngx_string("fastcgi_cache_min_uses"),
  442.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  443.       ngx_conf_set_num_slot,
  444.       NGX_HTTP_LOC_CONF_OFFSET,
  445.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_min_uses),
  446.       NULL },

  448.     { ngx_string("fastcgi_cache_max_range_offset"),
  449.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  450.       ngx_conf_set_off_slot,
  451.       NGX_HTTP_LOC_CONF_OFFSET,
  452.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_max_range_offset),
  453.       NULL },

  455.     { ngx_string("fastcgi_cache_use_stale"),
  456.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  457.       ngx_conf_set_bitmask_slot,
  458.       NGX_HTTP_LOC_CONF_OFFSET,
  459.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_use_stale),
  460.       &ngx_http_fastcgi_next_upstream_masks },

  462.     { ngx_string("fastcgi_cache_methods"),
  463.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  464.       ngx_conf_set_bitmask_slot,
  465.       NGX_HTTP_LOC_CONF_OFFSET,
  466.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_methods),
  467.       &ngx_http_upstream_cache_method_mask },

  469.     { ngx_string("fastcgi_cache_lock"),
  470.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  471.       ngx_conf_set_flag_slot,
  472.       NGX_HTTP_LOC_CONF_OFFSET,
  473.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_lock),
  474.       NULL },

  476.     { ngx_string("fastcgi_cache_lock_timeout"),
  477.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  478.       ngx_conf_set_msec_slot,
  479.       NGX_HTTP_LOC_CONF_OFFSET,
  480.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_lock_timeout),
  481.       NULL },

  483.     { ngx_string("fastcgi_cache_lock_age"),
  484.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  485.       ngx_conf_set_msec_slot,
  486.       NGX_HTTP_LOC_CONF_OFFSET,
  487.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_lock_age),
  488.       NULL },

  490.     { ngx_string("fastcgi_cache_revalidate"),
  491.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  492.       ngx_conf_set_flag_slot,
  493.       NGX_HTTP_LOC_CONF_OFFSET,
  494.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_revalidate),
  495.       NULL },

  497.     { ngx_string("fastcgi_cache_background_update"),
  498.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  499.       ngx_conf_set_flag_slot,
  500.       NGX_HTTP_LOC_CONF_OFFSET,
  501.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_background_update),
  502.       NULL },

  504. #endif

  506.     { ngx_string("fastcgi_temp_path"),
  507.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  508.       ngx_conf_set_path_slot,
  509.       NGX_HTTP_LOC_CONF_OFFSET,
  510.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.temp_path),
  511.       NULL },

  513.     { ngx_string("fastcgi_max_temp_file_size"),
  514.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  515.       ngx_conf_set_size_slot,
  516.       NGX_HTTP_LOC_CONF_OFFSET,
  517.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.max_temp_file_size_conf),
  518.       NULL },

  520.     { ngx_string("fastcgi_temp_file_write_size"),
  521.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  522.       ngx_conf_set_size_slot,
  523.       NGX_HTTP_LOC_CONF_OFFSET,
  524.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.temp_file_write_size_conf),
  525.       NULL },

  527.     { ngx_string("fastcgi_next_upstream"),
  528.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  529.       ngx_conf_set_bitmask_slot,
  530.       NGX_HTTP_LOC_CONF_OFFSET,
  531.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream),
  532.       &ngx_http_fastcgi_next_upstream_masks },

  534.     { ngx_string("fastcgi_next_upstream_tries"),
  535.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  536.       ngx_conf_set_num_slot,
  537.       NGX_HTTP_LOC_CONF_OFFSET,
  538.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream_tries),
  539.       NULL },

  541.     { ngx_string("fastcgi_next_upstream_timeout"),
  542.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  543.       ngx_conf_set_msec_slot,
  544.       NGX_HTTP_LOC_CONF_OFFSET,
  545.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream_timeout),
  546.       NULL },

  548.     { ngx_string("fastcgi_param"),
  549.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  550.       ngx_http_upstream_param_set_slot,
  551.       NGX_HTTP_LOC_CONF_OFFSET,
  552.       offsetof(ngx_http_fastcgi_loc_conf_t, params_source),
  553.       NULL },

  555.     { ngx_string("fastcgi_pass_header"),
  556.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  557.       ngx_conf_set_str_array_slot,
  558.       NGX_HTTP_LOC_CONF_OFFSET,
  559.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.pass_headers),
  560.       NULL },

  562.     { ngx_string("fastcgi_hide_header"),
  563.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  564.       ngx_conf_set_str_array_slot,
  565.       NGX_HTTP_LOC_CONF_OFFSET,
  566.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.hide_headers),
  567.       NULL },

  569.     { ngx_string("fastcgi_ignore_headers"),
  570.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  571.       ngx_conf_set_bitmask_slot,
  572.       NGX_HTTP_LOC_CONF_OFFSET,
  573.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.ignore_headers),
  574.       &ngx_http_upstream_ignore_headers_masks },

  576.     { ngx_string("fastcgi_catch_stderr"),
  577.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  578.       ngx_conf_set_str_array_slot,
  579.       NGX_HTTP_LOC_CONF_OFFSET,
  580.       offsetof(ngx_http_fastcgi_loc_conf_t, catch_stderr),
  581.       NULL },

  583.     { ngx_string("fastcgi_keep_conn"),
  584.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  585.       ngx_conf_set_flag_slot,
  586.       NGX_HTTP_LOC_CONF_OFFSET,
  587.       offsetof(ngx_http_fastcgi_loc_conf_t, keep_conn),
  588.       NULL },

  590.       ngx_null_command
  591. };


  594. ‌static ngx_http_module_t  ngx_http_fastcgi_module_ctx = {
  595.     ngx_http_fastcgi_add_variables,        /* preconfiguration */
  596.     NULL,                                  /* postconfiguration */

  598.     ngx_http_fastcgi_create_main_conf,     /* create main configuration */
  599.     NULL,                                  /* init main configuration */

  601.     NULL,                                  /* create server configuration */
  602.     NULL,                                  /* merge server configuration */

  604.     ngx_http_fastcgi_create_loc_conf,      /* create location configuration */
  605.     ngx_http_fastcgi_merge_loc_conf        /* merge location configuration */
  606. };


  609. ‌ngx_module_t  ngx_http_fastcgi_module = {
  610.     NGX_MODULE_V1,
  611.     &ngx_http_fastcgi_module_ctx,          /* module context */
  612.     ngx_http_fastcgi_commands,             /* module directives */
  613.     NGX_HTTP_MODULE,                       /* module type */
  614.     NULL,                                  /* init master */
  615.     NULL,                                  /* init module */
  616.     NULL,                                  /* init process */
  617.     NULL,                                  /* init thread */
  618.     NULL,                                  /* exit thread */
  619.     NULL,                                  /* exit process */
  620.     NULL,                                  /* exit master */
  621.     NGX_MODULE_V1_PADDING
  622. };


  625. ‌static ngx_http_fastcgi_request_start_t  ngx_http_fastcgi_request_start = {
  626.     { 1,                                               /* version */
  627.       NGX_HTTP_FASTCGI_BEGIN_REQUEST,                  /* type */
  628.       0,                                               /* request_id_hi */
  629.       1,                                               /* request_id_lo */
  630.       0,                                               /* content_length_hi */
  631.       sizeof(ngx_http_fastcgi_begin_request_t),        /* content_length_lo */
  632.       0,                                               /* padding_length */
  633.       0 },                                             /* reserved */

  635.     { 0,                                               /* role_hi */
  636.       NGX_HTTP_FASTCGI_RESPONDER,                      /* role_lo */
  637.       0, /* NGX_HTTP_FASTCGI_KEEP_CONN */              /* flags */
  638.       { 0, 0, 0, 0, 0 } },                             /* reserved[5] */

  640.     { 1,                                               /* version */
  641.       NGX_HTTP_FASTCGI_PARAMS,                         /* type */
  642.       0,                                               /* request_id_hi */
  643.       1 },                                             /* request_id_lo */

  645. };


  648. ‌static ngx_http_variable_t  ngx_http_fastcgi_vars[] = {

  650.     { ngx_string("fastcgi_script_name"), NULL,
  651.       ngx_http_fastcgi_script_name_variable, 0,
  652.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  654.     { ngx_string("fastcgi_path_info"), NULL,
  655.       ngx_http_fastcgi_path_info_variable, 0,
  656.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  658.       ngx_http_null_variable
  659. };


  662. ‌static ngx_str_t  ngx_http_fastcgi_hide_headers[] = {
  663.     ngx_string("Status"),
  664.     ngx_string("X-Accel-Expires"),
  665.     ngx_string("X-Accel-Redirect"),
  666.     ngx_string("X-Accel-Limit-Rate"),
  667.     ngx_string("X-Accel-Buffering"),
  668.     ngx_string("X-Accel-Charset"),
  669.     ngx_null_string
  670. };


  673. ‌static ngx_keyval_t  ngx_http_fastcgi_headers[] = {
  674.     { ngx_string("HTTP_HOST"),
  675.       ngx_string("$host$is_request_port$request_port") },
  676.     { ngx_null_string, ngx_null_string }
  677. };


  680. #if (NGX_HTTP_CACHE)

  682. ‌static ngx_keyval_t  ngx_http_fastcgi_cache_headers[] = {
  683.     { ngx_string("HTTP_HOST"),
  684.       ngx_string("$host$is_request_port$request_port") },
  685.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  686.       ngx_string("$upstream_cache_last_modified") },
  687.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  688.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  689.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  690.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  691.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  692.     { ngx_null_string, ngx_null_string }
  693. };

  695. #endif


  698. ‌static ngx_path_init_t  ngx_http_fastcgi_temp_path = {
  699.     ngx_string(NGX_HTTP_FASTCGI_TEMP_PATH), { 1, 2, 0 }
  700. };


  703. static ngx_int_t
  704. ‌ngx_http_fastcgi_handler(ngx_http_request_t *r)
  705. {
  706.     ngx_int_t                      rc;
  707.     ngx_http_upstream_t           *u;
  708.     ngx_http_fastcgi_ctx_t        *f;
  709.     ngx_http_fastcgi_loc_conf_t   *flcf;
  710. #if (NGX_HTTP_CACHE)
  711.     ngx_http_fastcgi_main_conf_t  *fmcf;
  712. #endif

  714.     if (ngx_http_upstream_create(r) != NGX_OK) {
  715.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  716.     }

  718.     f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  719.     if (f == NULL) {
  720.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  721.     }

  723.     ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);

  725.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  727.     if (flcf->fastcgi_lengths) {
  728.         if (ngx_http_fastcgi_eval(r, flcf) != NGX_OK) {
  729.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  730.         }
  731.     }

  733.     u = r->upstream;

  735.     ngx_str_set(&u->schema, "fastcgi://");
  736.     u->output.tag = (ngx_buf_tag_t) &ngx_http_fastcgi_module;

  738.     u->conf = &flcf->upstream;

  740. #if (NGX_HTTP_CACHE)
  741.     fmcf = ngx_http_get_module_main_conf(r, ngx_http_fastcgi_module);

  743.     u->caches = &fmcf->caches;
  744.     u->create_key = ngx_http_fastcgi_create_key;
  745. #endif

  747.     u->create_request = ngx_http_fastcgi_create_request;
  748.     u->reinit_request = ngx_http_fastcgi_reinit_request;
  749.     u->process_header = ngx_http_fastcgi_process_header;
  750.     u->abort_request = ngx_http_fastcgi_abort_request;
  751.     u->finalize_request = ngx_http_fastcgi_finalize_request;
  752.     r->state = 0;

  754.     u->buffering = flcf->upstream.buffering;

  756.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  757.     if (u->pipe == NULL) {
  758.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  759.     }

  761.     u->pipe->input_filter = ngx_http_fastcgi_input_filter;
  762.     u->pipe->input_ctx = r;

  764.     u->input_filter_init = ngx_http_fastcgi_input_filter_init;
  765.     u->input_filter = ngx_http_fastcgi_non_buffered_filter;
  766.     u->input_filter_ctx = r;

  768.     if (!flcf->upstream.request_buffering
  769.         && flcf->upstream.pass_request_body)
  770.     {
  771.         r->request_body_no_buffering = 1;
  772.     }

  774.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  776.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  777.         return rc;
  778.     }

  780.     return NGX_DONE;
  781. }


  784. static ngx_int_t
  785. ‌ngx_http_fastcgi_eval(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  786. {
  787.     ngx_url_t             url;
  788.     ngx_http_upstream_t  *u;

  790.     ngx_memzero(&url, sizeof(ngx_url_t));

  792.     if (ngx_http_script_run(r, &url.url, flcf->fastcgi_lengths->elts, 0,
  793.                             flcf->fastcgi_values->elts)
  794.         == NULL)
  795.     {
  796.         return NGX_ERROR;
  797.     }

  799.     url.no_resolve = 1;

  801.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  802.         if (url.err) {
  803.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  804.                           "%s in upstream \"%V\"", url.err, &url.url);
  805.         }

  807.         return NGX_ERROR;
  808.     }

  810.     u = r->upstream;

  812.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  813.     if (u->resolved == NULL) {
  814.         return NGX_ERROR;
  815.     }

  817.     if (url.addrs) {
  818.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  819.         u->resolved->socklen = url.addrs[0].socklen;
  820.         u->resolved->name = url.addrs[0].name;
  821.         u->resolved->naddrs = 1;
  822.     }

  824.     u->resolved->host = url.host;
  825.     u->resolved->port = url.port;
  826.     u->resolved->no_port = url.no_port;

  828.     return NGX_OK;
  829. }


  832. #if (NGX_HTTP_CACHE)

  834. static ngx_int_t
  835. ‌ngx_http_fastcgi_create_key(ngx_http_request_t *r)
  836. {
  837.     ngx_str_t                    *key;
  838.     ngx_http_fastcgi_loc_conf_t  *flcf;

  840.     key = ngx_array_push(&r->cache->keys);
  841.     if (key == NULL) {
  842.         return NGX_ERROR;
  843.     }

  845.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  847.     if (ngx_http_complex_value(r, &flcf->cache_key, key) != NGX_OK) {
  848.         return NGX_ERROR;
  849.     }

  851.     return NGX_OK;
  852. }

  854. #endif


  857. static ngx_int_t
  858. ‌ngx_http_fastcgi_create_request(ngx_http_request_t *r)
  859. {
  860.     off_t                         file_pos;
  861.     u_char                        ch, sep, *pos, *lowcase_key;
  862.     size_t                        size, len, params_len,
  863.                                   key_len, val_len, padding, allocated;
  864.     ngx_uint_t                    i, n, next, hash, skip_empty, header_params;
  865.     ngx_buf_t                    *b;
  866.     ngx_chain_t                  *cl, *body;
  867.     ngx_list_part_t              *part;
  868.     ngx_table_elt_t              *header, *hn, **ignored;
  869.     ngx_http_upstream_t          *u;
  870.     ngx_http_script_code_pt       code;
  871.     ngx_http_script_engine_t      e, le;
  872.     ngx_http_fastcgi_header_t    *h;
  873.     ngx_http_fastcgi_params_t    *params;
  874.     ngx_http_fastcgi_loc_conf_t  *flcf;
  875.     ngx_http_script_len_code_pt   lcode;

  877.     len = 0;
  878.     params_len = 0;
  879.     header_params = 0;
  880.     ignored = NULL;

  882.     u = r->upstream;

  884.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  886. #if (NGX_HTTP_CACHE)
  887.     params = u->cacheable ? &flcf->params_cache : &flcf->params;
  888. #else
  889.     params = &flcf->params;
  890. #endif

  892.     if (params->lengths) {
  893.         ngx_memzero(&le, sizeof(ngx_http_script_engine_t));

  895.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  896.         le.flushed = 1;

  898.         le.ip = params->lengths->elts;
  899.         le.request = r;

  901.         while (*(uintptr_t *) le.ip) {

  903.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  904.             key_len = lcode(&le);

  906.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  907.             skip_empty = lcode(&le);

  909.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  910.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  911.             }
  912.             le.ip += sizeof(uintptr_t);

  914.             if (skip_empty && val_len == 0) {
  915.                 continue;
  916.             }

  918.             params_len += ((key_len > 127) ? 4 : 1) + key_len
  919.                           + ((val_len > 127) ? 4 : 1) + val_len;
  920.         }

  922.         len += params_len;
  923.     }

  925.     if (flcf->upstream.pass_request_headers) {

  927.         allocated = 0;
  928.         lowcase_key = NULL;

  930.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  931.             return NGX_ERROR;
  932.         }

  934.         if (params->number || r->headers_in.multi) {
  935.             n = 0;
  936.             part = &r->headers_in.headers.part;

  938.             while (part) {
  939.                 n += part->nelts;
  940.                 part = part->next;
  941.             }

  943.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  944.             if (ignored == NULL) {
  945.                 return NGX_ERROR;
  946.             }
  947.         }

  949.         part = &r->headers_in.headers.part;
  950.         header = part->elts;

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

  954.             if (i >= part->nelts) {
  955.                 if (part->next == NULL) {
  956.                     break;
  957.                 }

  959.                 part = part->next;
  960.                 header = part->elts;
  961.                 i = 0;
  962.             }

  964.             for (n = 0; n < header_params; n++) {
  965.                 if (&header[i] == ignored[n]) {
  966.                     goto next_length;
  967.                 }
  968.             }

  970.             if (params->number) {
  971.                 if (allocated < header[i].key.len) {
  972.                     allocated = header[i].key.len + 16;
  973.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  974.                     if (lowcase_key == NULL) {
  975.                         return NGX_ERROR;
  976.                     }
  977.                 }

  979.                 hash = 0;

  981.                 for (n = 0; n < header[i].key.len; n++) {
  982.                     ch = header[i].key.data[n];

  984.                     if (ch >= 'A' && ch <= 'Z') {
  985.                         ch |= 0x20;

  987.                     } else if (ch == '-') {
  988.                         ch = '_';
  989.                     }

  991.                     hash = ngx_hash(hash, ch);
  992.                     lowcase_key[n] = ch;
  993.                 }

  995.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  996.                     ignored[header_params++] = &header[i];
  997.                     continue;
  998.                 }
  999.             }

  1001.             key_len = sizeof("HTTP_") - 1 + header[i].key.len;

  1003.             val_len = header[i].value.len;

  1005.             for (hn = header[i].next; hn; hn = hn->next) {
  1006.                 val_len += hn->value.len + 2;
  1007.                 ignored[header_params++] = hn;
  1008.             }

  1010.             len += ((key_len > 127) ? 4 : 1) + key_len
  1011.                    + ((val_len > 127) ? 4 : 1) + val_len;

  1013.         next_length:

  1015.             continue;
  1016.         }
  1017.     }


  1020.     if (len > 65535) {
  1021.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1022.                       "fastcgi request record is too big: %uz", len);
  1023.         return NGX_ERROR;
  1024.     }


  1027.     padding = 8 - len % 8;
  1028.     padding = (padding == 8) ? 0 : padding;


  1031.     size = sizeof(ngx_http_fastcgi_header_t)
  1032.            + sizeof(ngx_http_fastcgi_begin_request_t)

  1034.            + sizeof(ngx_http_fastcgi_header_t)  /* NGX_HTTP_FASTCGI_PARAMS */
  1035.            + len + padding
  1036.            + sizeof(ngx_http_fastcgi_header_t)  /* NGX_HTTP_FASTCGI_PARAMS */

  1038.            + sizeof(ngx_http_fastcgi_header_t); /* NGX_HTTP_FASTCGI_STDIN */


  1041.     b = ngx_create_temp_buf(r->pool, size);
  1042.     if (b == NULL) {
  1043.         return NGX_ERROR;
  1044.     }

  1046.     cl = ngx_alloc_chain_link(r->pool);
  1047.     if (cl == NULL) {
  1048.         return NGX_ERROR;
  1049.     }

  1051.     cl->buf = b;

  1053.     ngx_http_fastcgi_request_start.br.flags =
  1054.         flcf->keep_conn ? NGX_HTTP_FASTCGI_KEEP_CONN : 0;

  1056.     ngx_memcpy(b->pos, &ngx_http_fastcgi_request_start,
  1057.                sizeof(ngx_http_fastcgi_request_start_t));

  1059.     h = (ngx_http_fastcgi_header_t *)
  1060.              (b->pos + sizeof(ngx_http_fastcgi_header_t)
  1061.                      + sizeof(ngx_http_fastcgi_begin_request_t));

  1063.     h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1064.     h->content_length_lo = (u_char) (len & 0xff);
  1065.     h->padding_length = (u_char) padding;
  1066.     h->reserved = 0;

  1068.     b->last = b->pos + sizeof(ngx_http_fastcgi_header_t)
  1069.                      + sizeof(ngx_http_fastcgi_begin_request_t)
  1070.                      + sizeof(ngx_http_fastcgi_header_t);


  1073.     if (params->lengths) {
  1074.         ngx_memzero(&e, sizeof(ngx_http_script_engine_t));

  1076.         e.ip = params->values->elts;
  1077.         e.pos = b->last;
  1078.         e.end = b->last + params_len;
  1079.         e.request = r;
  1080.         e.flushed = 1;

  1082.         le.ip = params->lengths->elts;

  1084.         while (*(uintptr_t *) le.ip) {

  1086.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1087.             key_len = lcode(&le);

  1089.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1090.             skip_empty = lcode(&le);

  1092.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1093.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1094.             }
  1095.             le.ip += sizeof(uintptr_t);

  1097.             if (skip_empty && val_len == 0) {
  1098.                 e.skip = 1;

  1100.                 while (*(uintptr_t *) e.ip) {
  1101.                     code = *(ngx_http_script_code_pt *) e.ip;
  1102.                     code((ngx_http_script_engine_t *) &e);
  1103.                 }
  1104.                 e.ip += sizeof(uintptr_t);

  1106.                 e.skip = 0;

  1108.                 continue;
  1109.             }

  1111.             if (ngx_http_script_check_length(&e,
  1112.                                              ((key_len > 127) ? 4 : 1)
  1113.                                              + ((val_len > 127) ? 4 : 1))
  1114.                 != NGX_OK)
  1115.             {
  1116.                 return NGX_ERROR;
  1117.             }

  1119.             if (key_len > 127) {
  1120.                 *e.pos++ = (u_char) (((key_len >> 24) & 0x7f) | 0x80);
  1121.                 *e.pos++ = (u_char) ((key_len >> 16) & 0xff);
  1122.                 *e.pos++ = (u_char) ((key_len >> 8) & 0xff);
  1123.                 *e.pos++ = (u_char) (key_len & 0xff);

  1125.             } else {
  1126.                 *e.pos++ = (u_char) key_len;
  1127.             }

  1129.             if (val_len > 127) {
  1130.                 *e.pos++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1131.                 *e.pos++ = (u_char) ((val_len >> 16) & 0xff);
  1132.                 *e.pos++ = (u_char) ((val_len >> 8) & 0xff);
  1133.                 *e.pos++ = (u_char) (val_len & 0xff);

  1135.             } else {
  1136.                 *e.pos++ = (u_char) val_len;
  1137.             }

  1139.             while (*(uintptr_t *) e.ip) {
  1140.                 code = *(ngx_http_script_code_pt *) e.ip;
  1141.                 code((ngx_http_script_engine_t *) &e);
  1142.             }
  1143.             e.ip += sizeof(uintptr_t);

  1145.             if (e.status) {
  1146.                 return NGX_ERROR;
  1147.             }

  1149.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1150.                            "fastcgi param: \"%*s: %*s\"",
  1151.                            key_len, e.pos - (key_len + val_len),
  1152.                            val_len, e.pos - val_len);
  1153.         }

  1155.         if (e.pos != e.end) {
  1156.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1157.                           "fastcgi request length mismatch");
  1158.             return NGX_ERROR;
  1159.         }

  1161.         b->last = e.pos;
  1162.     }


  1165.     if (flcf->upstream.pass_request_headers) {

  1167.         part = &r->headers_in.headers.part;
  1168.         header = part->elts;

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

  1172.             if (i >= part->nelts) {
  1173.                 if (part->next == NULL) {
  1174.                     break;
  1175.                 }

  1177.                 part = part->next;
  1178.                 header = part->elts;
  1179.                 i = 0;
  1180.             }

  1182.             for (n = 0; n < header_params; n++) {
  1183.                 if (&header[i] == ignored[n]) {
  1184.                     goto next_value;
  1185.                 }
  1186.             }

  1188.             key_len = sizeof("HTTP_") - 1 + header[i].key.len;
  1189.             if (key_len > 127) {
  1190.                 *b->last++ = (u_char) (((key_len >> 24) & 0x7f) | 0x80);
  1191.                 *b->last++ = (u_char) ((key_len >> 16) & 0xff);
  1192.                 *b->last++ = (u_char) ((key_len >> 8) & 0xff);
  1193.                 *b->last++ = (u_char) (key_len & 0xff);

  1195.             } else {
  1196.                 *b->last++ = (u_char) key_len;
  1197.             }

  1199.             val_len = header[i].value.len;

  1201.             for (hn = header[i].next; hn; hn = hn->next) {
  1202.                 val_len += hn->value.len + 2;
  1203.             }

  1205.             if (val_len > 127) {
  1206.                 *b->last++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1207.                 *b->last++ = (u_char) ((val_len >> 16) & 0xff);
  1208.                 *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1209.                 *b->last++ = (u_char) (val_len & 0xff);

  1211.             } else {
  1212.                 *b->last++ = (u_char) val_len;
  1213.             }

  1215.             b->last = ngx_cpymem(b->last, "HTTP_", sizeof("HTTP_") - 1);

  1217.             for (n = 0; n < header[i].key.len; n++) {
  1218.                 ch = header[i].key.data[n];

  1220.                 if (ch >= 'a' && ch <= 'z') {
  1221.                     ch &= ~0x20;

  1223.                 } else if (ch == '-') {
  1224.                     ch = '_';
  1225.                 }

  1227.                 *b->last++ = ch;
  1228.             }

  1230.             b->last = ngx_copy(b->last, header[i].value.data,
  1231.                                header[i].value.len);

  1233.             if (header[i].next) {

  1235.                 if (header[i].key.len == sizeof("Cookie") - 1
  1236.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1237.                                        sizeof("Cookie") - 1)
  1238.                        == 0)
  1239.                 {
  1240.                     sep = ';';

  1242.                 } else {
  1243.                     sep = ',';
  1244.                 }

  1246.                 for (hn = header[i].next; hn; hn = hn->next) {
  1247.                     *b->last++ = sep;
  1248.                     *b->last++ = ' ';
  1249.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1250.                 }
  1251.             }

  1253.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1254.                            "fastcgi param: \"%*s: %*s\"",
  1255.                            key_len, b->last - (key_len + val_len),
  1256.                            val_len, b->last - val_len);
  1257.         next_value:

  1259.             continue;
  1260.         }
  1261.     }


  1264.     if (padding) {
  1265.         ngx_memzero(b->last, padding);
  1266.         b->last += padding;
  1267.     }


  1270.     h = (ngx_http_fastcgi_header_t *) b->last;
  1271.     b->last += sizeof(ngx_http_fastcgi_header_t);

  1273.     h->version = 1;
  1274.     h->type = NGX_HTTP_FASTCGI_PARAMS;
  1275.     h->request_id_hi = 0;
  1276.     h->request_id_lo = 1;
  1277.     h->content_length_hi = 0;
  1278.     h->content_length_lo = 0;
  1279.     h->padding_length = 0;
  1280.     h->reserved = 0;

  1282.     if (r->request_body_no_buffering) {

  1284.         u->request_bufs = cl;

  1286.         u->output.output_filter = ngx_http_fastcgi_body_output_filter;
  1287.         u->output.filter_ctx = r;

  1289.     } else if (flcf->upstream.pass_request_body) {

  1291.         body = u->request_bufs;
  1292.         u->request_bufs = cl;

  1294. #if (NGX_SUPPRESS_WARN)
  1295.         file_pos = 0;
  1296.         pos = NULL;
  1297. #endif

  1299.         while (body) {

  1301.             if (ngx_buf_special(body->buf)) {
  1302.                 body = body->next;
  1303.                 continue;
  1304.             }

  1306.             if (body->buf->in_file) {
  1307.                 file_pos = body->buf->file_pos;

  1309.             } else {
  1310.                 pos = body->buf->pos;
  1311.             }

  1313.             next = 0;

  1315.             do {
  1316.                 b = ngx_alloc_buf(r->pool);
  1317.                 if (b == NULL) {
  1318.                     return NGX_ERROR;
  1319.                 }

  1321.                 ngx_memcpy(b, body->buf, sizeof(ngx_buf_t));

  1323.                 if (body->buf->in_file) {
  1324.                     b->file_pos = file_pos;
  1325.                     file_pos += 32 * 1024;

  1327.                     if (file_pos >= body->buf->file_last) {
  1328.                         file_pos = body->buf->file_last;
  1329.                         next = 1;
  1330.                     }

  1332.                     b->file_last = file_pos;
  1333.                     len = (ngx_uint_t) (file_pos - b->file_pos);

  1335.                 } else {
  1336.                     b->pos = pos;
  1337.                     b->start = pos;
  1338.                     pos += 32 * 1024;

  1340.                     if (pos >= body->buf->last) {
  1341.                         pos = body->buf->last;
  1342.                         next = 1;
  1343.                     }

  1345.                     b->last = pos;
  1346.                     len = (ngx_uint_t) (pos - b->pos);
  1347.                 }

  1349.                 padding = 8 - len % 8;
  1350.                 padding = (padding == 8) ? 0 : padding;

  1352.                 h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1353.                 cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1355.                 h->version = 1;
  1356.                 h->type = NGX_HTTP_FASTCGI_STDIN;
  1357.                 h->request_id_hi = 0;
  1358.                 h->request_id_lo = 1;
  1359.                 h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1360.                 h->content_length_lo = (u_char) (len & 0xff);
  1361.                 h->padding_length = (u_char) padding;
  1362.                 h->reserved = 0;

  1364.                 cl->next = ngx_alloc_chain_link(r->pool);
  1365.                 if (cl->next == NULL) {
  1366.                     return NGX_ERROR;
  1367.                 }

  1369.                 cl = cl->next;
  1370.                 cl->buf = b;

  1372.                 b = ngx_create_temp_buf(r->pool,
  1373.                                         sizeof(ngx_http_fastcgi_header_t)
  1374.                                         + padding);
  1375.                 if (b == NULL) {
  1376.                     return NGX_ERROR;
  1377.                 }

  1379.                 if (padding) {
  1380.                     ngx_memzero(b->last, padding);
  1381.                     b->last += padding;
  1382.                 }

  1384.                 cl->next = ngx_alloc_chain_link(r->pool);
  1385.                 if (cl->next == NULL) {
  1386.                     return NGX_ERROR;
  1387.                 }

  1389.                 cl = cl->next;
  1390.                 cl->buf = b;

  1392.             } while (!next);

  1394.             body = body->next;
  1395.         }

  1397.     } else {
  1398.         u->request_bufs = cl;
  1399.     }

  1401.     if (!r->request_body_no_buffering) {
  1402.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1403.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1405.         h->version = 1;
  1406.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1407.         h->request_id_hi = 0;
  1408.         h->request_id_lo = 1;
  1409.         h->content_length_hi = 0;
  1410.         h->content_length_lo = 0;
  1411.         h->padding_length = 0;
  1412.         h->reserved = 0;
  1413.     }

  1415.     cl->next = NULL;

  1417.     return NGX_OK;
  1418. }


  1421. static ngx_int_t
  1422. ‌ngx_http_fastcgi_reinit_request(ngx_http_request_t *r)
  1423. {
  1424.     ngx_http_fastcgi_ctx_t  *f;

  1426.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1428.     if (f == NULL) {
  1429.         return NGX_OK;
  1430.     }

  1432.     f->state = ngx_http_fastcgi_st_version;
  1433.     f->fastcgi_stdout = 0;
  1434.     f->large_stderr = 0;

  1436.     if (f->split_parts) {
  1437.         f->split_parts->nelts = 0;
  1438.     }

  1440.     r->state = 0;

  1442.     return NGX_OK;
  1443. }


  1446. static ngx_int_t
  1447. ‌ngx_http_fastcgi_body_output_filter(void *data, ngx_chain_t *in)
  1448. {
  1449.     ngx_http_request_t  *r = data;

  1451.     off_t                       file_pos;
  1452.     u_char                     *pos, *start;
  1453.     size_t                      len, padding;
  1454.     ngx_buf_t                  *b;
  1455.     ngx_int_t                   rc;
  1456.     ngx_uint_t                  next, last;
  1457.     ngx_chain_t                *cl, *tl, *out, **ll;
  1458.     ngx_http_fastcgi_ctx_t     *f;
  1459.     ngx_http_fastcgi_header_t  *h;

  1461.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1462.                    "fastcgi output filter");

  1464.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1466.     if (in == NULL) {
  1467.         out = in;
  1468.         goto out;
  1469.     }

  1471.     out = NULL;
  1472.     ll = &out;

  1474.     if (!f->header_sent) {
  1475.         /* first buffer contains headers, pass it unmodified */

  1477.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1478.                        "fastcgi output header");

  1480.         f->header_sent = 1;

  1482.         tl = ngx_alloc_chain_link(r->pool);
  1483.         if (tl == NULL) {
  1484.             return NGX_ERROR;
  1485.         }

  1487.         tl->buf = in->buf;
  1488.         *ll = tl;
  1489.         ll = &tl->next;

  1491.         in = in->next;

  1493.         if (in == NULL) {
  1494.             tl->next = NULL;
  1495.             goto out;
  1496.         }
  1497.     }

  1499.     cl = ngx_chain_get_free_buf(r->pool, &f->free);
  1500.     if (cl == NULL) {
  1501.         return NGX_ERROR;
  1502.     }

  1504.     b = cl->buf;

  1506.     b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1507.     b->temporary = 1;

  1509.     if (b->start == NULL) {
  1510.         /* reserve space for maximum possible padding, 7 bytes */

  1512.         b->start = ngx_palloc(r->pool,
  1513.                               sizeof(ngx_http_fastcgi_header_t) + 7);
  1514.         if (b->start == NULL) {
  1515.             return NGX_ERROR;
  1516.         }

  1518.         b->pos = b->start;
  1519.         b->last = b->start;

  1521.         b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1522.     }

  1524.     *ll = cl;

  1526.     last = 0;
  1527.     padding = 0;

  1529. #if (NGX_SUPPRESS_WARN)
  1530.     file_pos = 0;
  1531.     pos = NULL;
  1532. #endif

  1534.     while (in) {

  1536.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1537.                        "fastcgi output in  l:%d f:%d %p, pos %p, size: %z "
  1538.                        "file: %O, size: %O",
  1539.                        in->buf->last_buf,
  1540.                        in->buf->in_file,
  1541.                        in->buf->start, in->buf->pos,
  1542.                        in->buf->last - in->buf->pos,
  1543.                        in->buf->file_pos,
  1544.                        in->buf->file_last - in->buf->file_pos);

  1546.         if (in->buf->last_buf) {
  1547.             last = 1;
  1548.         }

  1550.         if (ngx_buf_special(in->buf)) {
  1551.             in = in->next;
  1552.             continue;
  1553.         }

  1555.         if (in->buf->in_file) {
  1556.             file_pos = in->buf->file_pos;

  1558.         } else {
  1559.             pos = in->buf->pos;
  1560.         }

  1562.         next = 0;

  1564.         do {
  1565.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1566.             if (tl == NULL) {
  1567.                 return NGX_ERROR;
  1568.             }

  1570.             b = tl->buf;
  1571.             start = b->start;

  1573.             ngx_memcpy(b, in->buf, sizeof(ngx_buf_t));

  1575.             /*
  1576.              * restore b->start to preserve memory allocated in the buffer,
  1577.              * to reuse it later for headers and padding
  1578.              */

  1580.             b->start = start;

  1582.             if (in->buf->in_file) {
  1583.                 b->file_pos = file_pos;
  1584.                 file_pos += 32 * 1024;

  1586.                 if (file_pos >= in->buf->file_last) {
  1587.                     file_pos = in->buf->file_last;
  1588.                     next = 1;
  1589.                 }

  1591.                 b->file_last = file_pos;
  1592.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1594.             } else {
  1595.                 b->pos = pos;
  1596.                 pos += 32 * 1024;

  1598.                 if (pos >= in->buf->last) {
  1599.                     pos = in->buf->last;
  1600.                     next = 1;
  1601.                 }

  1603.                 b->last = pos;
  1604.                 len = (ngx_uint_t) (pos - b->pos);
  1605.             }

  1607.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1608.             b->shadow = in->buf;
  1609.             b->last_shadow = next;

  1611.             b->last_buf = 0;
  1612.             b->last_in_chain = 0;

  1614.             padding = 8 - len % 8;
  1615.             padding = (padding == 8) ? 0 : padding;

  1617.             h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1618.             cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1620.             h->version = 1;
  1621.             h->type = NGX_HTTP_FASTCGI_STDIN;
  1622.             h->request_id_hi = 0;
  1623.             h->request_id_lo = 1;
  1624.             h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1625.             h->content_length_lo = (u_char) (len & 0xff);
  1626.             h->padding_length = (u_char) padding;
  1627.             h->reserved = 0;

  1629.             cl->next = tl;
  1630.             cl = tl;

  1632.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1633.             if (tl == NULL) {
  1634.                 return NGX_ERROR;
  1635.             }

  1637.             b = tl->buf;

  1639.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1640.             b->temporary = 1;

  1642.             if (b->start == NULL) {
  1643.                 /* reserve space for maximum possible padding, 7 bytes */

  1645.                 b->start = ngx_palloc(r->pool,
  1646.                                       sizeof(ngx_http_fastcgi_header_t) + 7);
  1647.                 if (b->start == NULL) {
  1648.                     return NGX_ERROR;
  1649.                 }

  1651.                 b->pos = b->start;
  1652.                 b->last = b->start;

  1654.                 b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1655.             }

  1657.             if (padding) {
  1658.                 ngx_memzero(b->last, padding);
  1659.                 b->last += padding;
  1660.             }

  1662.             cl->next = tl;
  1663.             cl = tl;

  1665.         } while (!next);

  1667.         in = in->next;
  1668.     }

  1670.     if (last) {
  1671.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1672.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1674.         h->version = 1;
  1675.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1676.         h->request_id_hi = 0;
  1677.         h->request_id_lo = 1;
  1678.         h->content_length_hi = 0;
  1679.         h->content_length_lo = 0;
  1680.         h->padding_length = 0;
  1681.         h->reserved = 0;

  1683.         cl->buf->last_buf = 1;

  1685.     } else if (padding == 0) {
  1686.         /* TODO: do not allocate buffers instead */
  1687.         cl->buf->temporary = 0;
  1688.         cl->buf->sync = 1;
  1689.     }

  1691.     cl->next = NULL;

  1693. out:

  1695. #if (NGX_DEBUG)

  1697.     for (cl = out; cl; cl = cl->next) {
  1698.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1699.                        "fastcgi output out l:%d f:%d %p, pos %p, size: %z "
  1700.                        "file: %O, size: %O",
  1701.                        cl->buf->last_buf,
  1702.                        cl->buf->in_file,
  1703.                        cl->buf->start, cl->buf->pos,
  1704.                        cl->buf->last - cl->buf->pos,
  1705.                        cl->buf->file_pos,
  1706.                        cl->buf->file_last - cl->buf->file_pos);
  1707.     }

  1709. #endif

  1711.     rc = ngx_chain_writer(&r->upstream->writer, out);

  1713.     ngx_chain_update_chains(r->pool, &f->free, &f->busy, &out,
  1714.                          (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter);

  1716.     for (cl = f->free; cl; cl = cl->next) {

  1718.         /* mark original buffers as sent */

  1720.         if (cl->buf->shadow) {
  1721.             if (cl->buf->last_shadow) {
  1722.                 b = cl->buf->shadow;
  1723.                 b->pos = b->last;
  1724.             }

  1726.             cl->buf->shadow = NULL;
  1727.         }
  1728.     }

  1730.     return rc;
  1731. }


  1734. static ngx_int_t
  1735. ‌ngx_http_fastcgi_process_header(ngx_http_request_t *r)
  1736. {
  1737.     u_char                         *p, *msg, *start, *last,
  1738.                                    *part_start, *part_end;
  1739.     size_t                          size;
  1740.     ngx_str_t                      *status_line, *pattern;
  1741.     ngx_int_t                       rc, status;
  1742.     ngx_buf_t                       buf;
  1743.     ngx_uint_t                      i;
  1744.     ngx_table_elt_t                *h;
  1745.     ngx_http_upstream_t            *u;
  1746.     ngx_http_fastcgi_ctx_t         *f;
  1747.     ngx_http_upstream_header_t     *hh;
  1748.     ngx_http_fastcgi_loc_conf_t    *flcf;
  1749.     ngx_http_fastcgi_split_part_t  *part;
  1750.     ngx_http_upstream_main_conf_t  *umcf;

  1752.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1754.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1756.     u = r->upstream;

  1758.     for ( ;; ) {

  1760.         if (f->state < ngx_http_fastcgi_st_data) {

  1762.             f->pos = u->buffer.pos;
  1763.             f->last = u->buffer.last;

  1765.             rc = ngx_http_fastcgi_process_record(r, f);

  1767.             u->buffer.pos = f->pos;
  1768.             u->buffer.last = f->last;

  1770.             if (rc == NGX_AGAIN) {
  1771.                 return NGX_AGAIN;
  1772.             }

  1774.             if (rc == NGX_ERROR) {
  1775.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1776.             }

  1778.             if (f->type != NGX_HTTP_FASTCGI_STDOUT
  1779.                 && f->type != NGX_HTTP_FASTCGI_STDERR)
  1780.             {
  1781.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1782.                               "upstream sent unexpected FastCGI record: %ui",
  1783.                               f->type);

  1785.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1786.             }

  1788.             if (f->type == NGX_HTTP_FASTCGI_STDOUT && f->length == 0) {
  1789.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1790.                               "upstream prematurely closed FastCGI stdout");

  1792.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1793.             }
  1794.         }

  1796.         if (f->state == ngx_http_fastcgi_st_padding) {

  1798.             if (u->buffer.pos + f->padding < u->buffer.last) {
  1799.                 f->state = ngx_http_fastcgi_st_version;
  1800.                 u->buffer.pos += f->padding;

  1802.                 continue;
  1803.             }

  1805.             if (u->buffer.pos + f->padding == u->buffer.last) {
  1806.                 f->state = ngx_http_fastcgi_st_version;
  1807.                 u->buffer.pos = u->buffer.last;

  1809.                 return NGX_AGAIN;
  1810.             }

  1812.             f->padding -= u->buffer.last - u->buffer.pos;
  1813.             u->buffer.pos = u->buffer.last;

  1815.             return NGX_AGAIN;
  1816.         }


  1819.         /* f->state == ngx_http_fastcgi_st_data */

  1821.         if (f->type == NGX_HTTP_FASTCGI_STDERR) {

  1823.             if (f->length) {
  1824.                 msg = u->buffer.pos;

  1826.                 if (u->buffer.pos + f->length <= u->buffer.last) {
  1827.                     u->buffer.pos += f->length;
  1828.                     f->length = 0;
  1829.                     f->state = ngx_http_fastcgi_st_padding;

  1831.                 } else {
  1832.                     f->length -= u->buffer.last - u->buffer.pos;
  1833.                     u->buffer.pos = u->buffer.last;
  1834.                 }

  1836.                 for (p = u->buffer.pos - 1; msg < p; p--) {
  1837.                     if (*p != LF && *p != CR && *p != '.' && *p != ' ') {
  1838.                         break;
  1839.                     }
  1840.                 }

  1842.                 p++;

  1844.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1845.                               "FastCGI sent in stderr: \"%*s\"", p - msg, msg);

  1847.                 flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  1849.                 if (flcf->catch_stderr) {
  1850.                     pattern = flcf->catch_stderr->elts;

  1852.                     for (i = 0; i < flcf->catch_stderr->nelts; i++) {
  1853.                         if (ngx_strnstr(msg, (char *) pattern[i].data,
  1854.                                         p - msg)
  1855.                             != NULL)
  1856.                         {
  1857.                             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1858.                         }
  1859.                     }
  1860.                 }

  1862.                 if (u->buffer.pos == u->buffer.last) {

  1864.                     if (!f->fastcgi_stdout) {

  1866.                         /*
  1867.                          * the special handling the large number
  1868.                          * of the PHP warnings to not allocate memory
  1869.                          */

  1871. #if (NGX_HTTP_CACHE)
  1872.                         if (r->cache) {
  1873.                             u->buffer.pos = u->buffer.start
  1874.                                                      + r->cache->header_start;
  1875.                         } else {
  1876.                             u->buffer.pos = u->buffer.start;
  1877.                         }
  1878. #else
  1879.                         u->buffer.pos = u->buffer.start;
  1880. #endif
  1881.                         u->buffer.last = u->buffer.pos;
  1882.                         f->large_stderr = 1;
  1883.                     }

  1885.                     return NGX_AGAIN;
  1886.                 }

  1888.             } else {
  1889.                 f->state = ngx_http_fastcgi_st_padding;
  1890.             }

  1892.             continue;
  1893.         }


  1896.         /* f->type == NGX_HTTP_FASTCGI_STDOUT */

  1898. #if (NGX_HTTP_CACHE)

  1900.         if (f->large_stderr && r->cache) {
  1901.             ssize_t                     len;
  1902.             ngx_http_fastcgi_header_t  *fh;

  1904.             start = u->buffer.start + r->cache->header_start;

  1906.             len = u->buffer.pos - start - 2 * sizeof(ngx_http_fastcgi_header_t);

  1908.             /*
  1909.              * A tail of large stderr output before HTTP header is placed
  1910.              * in a cache file without a FastCGI record header.
  1911.              * To workaround it we put a dummy FastCGI record header at the
  1912.              * start of the stderr output or update r->cache_header_start,
  1913.              * if there is no enough place for the record header.
  1914.              */

  1916.             if (len >= 0) {
  1917.                 fh = (ngx_http_fastcgi_header_t *) start;
  1918.                 fh->version = 1;
  1919.                 fh->type = NGX_HTTP_FASTCGI_STDERR;
  1920.                 fh->request_id_hi = 0;
  1921.                 fh->request_id_lo = 1;
  1922.                 fh->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1923.                 fh->content_length_lo = (u_char) (len & 0xff);
  1924.                 fh->padding_length = 0;
  1925.                 fh->reserved = 0;

  1927.             } else {
  1928.                 r->cache->header_start += u->buffer.pos - start
  1929.                                           - sizeof(ngx_http_fastcgi_header_t);
  1930.             }

  1932.             f->large_stderr = 0;
  1933.         }

  1935. #endif

  1937.         f->fastcgi_stdout = 1;

  1939.         start = u->buffer.pos;

  1941.         if (u->buffer.pos + f->length < u->buffer.last) {

  1943.             /*
  1944.              * set u->buffer.last to the end of the FastCGI record data
  1945.              * for ngx_http_parse_header_line()
  1946.              */

  1948.             last = u->buffer.last;
  1949.             u->buffer.last = u->buffer.pos + f->length;

  1951.         } else {
  1952.             last = NULL;
  1953.         }

  1955.         for ( ;; ) {

  1957.             part_start = u->buffer.pos;
  1958.             part_end = u->buffer.last;

  1960.             rc = ngx_http_parse_header_line(r, &u->buffer, 1);

  1962.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1963.                            "http fastcgi parser: %i", rc);

  1965.             if (rc == NGX_AGAIN) {
  1966.                 break;
  1967.             }

  1969.             if (rc == NGX_OK) {

  1971.                 /* a header line has been parsed successfully */

  1973.                 h = ngx_list_push(&u->headers_in.headers);
  1974.                 if (h == NULL) {
  1975.                     return NGX_ERROR;
  1976.                 }

  1978.                 if (f->split_parts && f->split_parts->nelts) {

  1980.                     part = f->split_parts->elts;
  1981.                     size = u->buffer.pos - part_start;

  1983.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1984.                         size += part[i].end - part[i].start;
  1985.                     }

  1987.                     p = ngx_pnalloc(r->pool, size);
  1988.                     if (p == NULL) {
  1989.                         h->hash = 0;
  1990.                         return NGX_ERROR;
  1991.                     }

  1993.                     buf.pos = p;

  1995.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1996.                         p = ngx_cpymem(p, part[i].start,
  1997.                                        part[i].end - part[i].start);
  1998.                     }

  2000.                     p = ngx_cpymem(p, part_start, u->buffer.pos - part_start);

  2002.                     buf.last = p;

  2004.                     f->split_parts->nelts = 0;

  2006.                     rc = ngx_http_parse_header_line(r, &buf, 1);

  2008.                     if (rc != NGX_OK) {
  2009.                         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  2010.                                       "invalid header after joining "
  2011.                                       "FastCGI records");
  2012.                         h->hash = 0;
  2013.                         return NGX_ERROR;
  2014.                     }

  2016.                     h->key.len = r->header_name_end - r->header_name_start;
  2017.                     h->key.data = r->header_name_start;
  2018.                     h->key.data[h->key.len] = '\0';

  2020.                     h->value.len = r->header_end - r->header_start;
  2021.                     h->value.data = r->header_start;
  2022.                     h->value.data[h->value.len] = '\0';

  2024.                     h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  2025.                     if (h->lowcase_key == NULL) {
  2026.                         return NGX_ERROR;
  2027.                     }

  2029.                 } else {

  2031.                     h->key.len = r->header_name_end - r->header_name_start;
  2032.                     h->value.len = r->header_end - r->header_start;

  2034.                     h->key.data = ngx_pnalloc(r->pool,
  2035.                                               h->key.len + 1 + h->value.len + 1
  2036.                                               + h->key.len);
  2037.                     if (h->key.data == NULL) {
  2038.                         h->hash = 0;
  2039.                         return NGX_ERROR;
  2040.                     }

  2042.                     h->value.data = h->key.data + h->key.len + 1;
  2043.                     h->lowcase_key = h->key.data + h->key.len + 1
  2044.                                      + h->value.len + 1;

  2046.                     ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  2047.                     h->key.data[h->key.len] = '\0';
  2048.                     ngx_memcpy(h->value.data, r->header_start, h->value.len);
  2049.                     h->value.data[h->value.len] = '\0';
  2050.                 }

  2052.                 h->hash = r->header_hash;

  2054.                 if (h->key.len == r->lowcase_index) {
  2055.                     ngx_memcpy(h->lowcase_key, r->lowcase_header, h->key.len);

  2057.                 } else {
  2058.                     ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  2059.                 }

  2061.                 hh = ngx_hash_find(&umcf->headers_in_hash, h->hash,
  2062.                                    h->lowcase_key, h->key.len);

  2064.                 if (hh) {
  2065.                     rc = hh->handler(r, h, hh->offset);

  2067.                     if (rc != NGX_OK) {
  2068.                         return rc;
  2069.                     }
  2070.                 }

  2072.                 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2073.                                "http fastcgi header: \"%V: %V\"",
  2074.                                &h->key, &h->value);

  2076.                 if (u->buffer.pos < u->buffer.last) {
  2077.                     continue;
  2078.                 }

  2080.                 /* the end of the FastCGI record */

  2082.                 break;
  2083.             }

  2085.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

  2087.                 /* a whole header has been parsed successfully */

  2089.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2090.                                "http fastcgi header done");

  2092.                 if (u->headers_in.status) {
  2093.                     status_line = &u->headers_in.status->value;

  2095.                     status = ngx_atoi(status_line->data, 3);

  2097.                     if (status == NGX_ERROR) {
  2098.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2099.                                       "upstream sent invalid status \"%V\"",
  2100.                                       status_line);
  2101.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2102.                     }

  2104.                     u->headers_in.status_n = status;

  2106.                     if (status_line->len > 3) {
  2107.                         u->headers_in.status_line = *status_line;
  2108.                     }

  2110.                 } else if (u->headers_in.location) {
  2111.                     u->headers_in.status_n = 302;
  2112.                     ngx_str_set(&u->headers_in.status_line,
  2113.                                 "302 Moved Temporarily");

  2115.                 } else {
  2116.                     u->headers_in.status_n = 200;
  2117.                     ngx_str_set(&u->headers_in.status_line, "200 OK");
  2118.                 }

  2120.                 if (u->state && u->state->status == 0) {
  2121.                     u->state->status = u->headers_in.status_n;
  2122.                 }

  2124.                 break;
  2125.             }

  2127.             /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  2129.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2130.                           "upstream sent invalid header: \"%*s\\x%02xd...\"",
  2131.                           r->header_end - r->header_name_start,
  2132.                           r->header_name_start, *r->header_end);

  2134.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2135.         }

  2137.         if (last) {
  2138.             u->buffer.last = last;
  2139.         }

  2141.         f->length -= u->buffer.pos - start;

  2143.         if (f->length == 0) {
  2144.             f->state = ngx_http_fastcgi_st_padding;
  2145.         }

  2147.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2148.             return NGX_OK;
  2149.         }

  2151.         if (rc == NGX_OK) {
  2152.             continue;
  2153.         }

  2155.         /* rc == NGX_AGAIN */

  2157.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2158.                        "upstream split a header line in FastCGI records");

  2160.         if (f->split_parts == NULL) {
  2161.             f->split_parts = ngx_array_create(r->pool, 1,
  2162.                                         sizeof(ngx_http_fastcgi_split_part_t));
  2163.             if (f->split_parts == NULL) {
  2164.                 return NGX_ERROR;
  2165.             }
  2166.         }

  2168.         part = ngx_array_push(f->split_parts);
  2169.         if (part == NULL) {
  2170.             return NGX_ERROR;
  2171.         }

  2173.         part->start = part_start;
  2174.         part->end = part_end;

  2176.         if (u->buffer.pos < u->buffer.last) {
  2177.             continue;
  2178.         }

  2180.         return NGX_AGAIN;
  2181.     }
  2182. }


  2185. static ngx_int_t
  2186. ‌ngx_http_fastcgi_input_filter_init(void *data)
  2187. {
  2188.     ngx_http_request_t  *r = data;

  2190.     ngx_http_upstream_t          *u;
  2191.     ngx_http_fastcgi_ctx_t       *f;
  2192.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2194.     u = r->upstream;

  2196.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2197.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  2199.     u->pipe->length = flcf->keep_conn ?
  2200.                       (off_t) sizeof(ngx_http_fastcgi_header_t) : -1;

  2202.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  2203.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  2204.     {
  2205.         f->rest = 0;

  2207.     } else if (r->method == NGX_HTTP_HEAD) {
  2208.         f->rest = -2;

  2210.     } else {
  2211.         f->rest = u->headers_in.content_length_n;
  2212.     }

  2214.     return NGX_OK;
  2215. }


  2218. static ngx_int_t
  2219. ‌ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
  2220. {
  2221.     u_char                       *m, *msg;
  2222.     ngx_int_t                     rc;
  2223.     ngx_buf_t                    *b, **prev;
  2224.     ngx_chain_t                  *cl;
  2225.     ngx_http_request_t           *r;
  2226.     ngx_http_fastcgi_ctx_t       *f;
  2227.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2229.     if (buf->pos == buf->last) {
  2230.         return NGX_OK;
  2231.     }

  2233.     r = p->input_ctx;
  2234.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2235.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  2237.     if (p->upstream_done || f->closed) {
  2238.         r->upstream->keepalive = 0;

  2240.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, p->log, 0,
  2241.                        "http fastcgi data after close");

  2243.         return NGX_OK;
  2244.     }

  2246.     b = NULL;
  2247.     prev = &buf->shadow;

  2249.     f->pos = buf->pos;
  2250.     f->last = buf->last;

  2252.     for ( ;; ) {
  2253.         if (f->state < ngx_http_fastcgi_st_data) {

  2255.             rc = ngx_http_fastcgi_process_record(r, f);

  2257.             if (rc == NGX_AGAIN) {
  2258.                 break;
  2259.             }

  2261.             if (rc == NGX_ERROR) {
  2262.                 return NGX_ERROR;
  2263.             }

  2265.             if (f->type == NGX_HTTP_FASTCGI_STDOUT && f->length == 0) {
  2266.                 f->state = ngx_http_fastcgi_st_padding;

  2268.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, p->log, 0,
  2269.                                "http fastcgi closed stdout");

  2271.                 if (f->rest > 0) {
  2272.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2273.                                   "upstream prematurely closed "
  2274.                                   "FastCGI stdout");

  2276.                     p->upstream_error = 1;
  2277.                     p->upstream_eof = 0;
  2278.                     f->closed = 1;

  2280.                     break;
  2281.                 }

  2283.                 if (!flcf->keep_conn) {
  2284.                     p->upstream_done = 1;
  2285.                 }

  2287.                 continue;
  2288.             }

  2290.             if (f->type == NGX_HTTP_FASTCGI_END_REQUEST) {

  2292.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, p->log, 0,
  2293.                                "http fastcgi sent end request");

  2295.                 if (f->rest > 0) {
  2296.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2297.                                   "upstream prematurely closed "
  2298.                                   "FastCGI request");

  2300.                     p->upstream_error = 1;
  2301.                     p->upstream_eof = 0;
  2302.                     f->closed = 1;

  2304.                     break;
  2305.                 }

  2307.                 if (!flcf->keep_conn) {
  2308.                     p->upstream_done = 1;
  2309.                     break;
  2310.                 }

  2312.                 continue;
  2313.             }
  2314.         }


  2317.         if (f->state == ngx_http_fastcgi_st_padding) {

  2319.             if (f->type == NGX_HTTP_FASTCGI_END_REQUEST) {

  2321.                 if (f->pos + f->padding < f->last) {
  2322.                     p->upstream_done = 1;
  2323.                     break;
  2324.                 }

  2326.                 if (f->pos + f->padding == f->last) {
  2327.                     p->upstream_done = 1;
  2328.                     r->upstream->keepalive = 1;
  2329.                     break;
  2330.                 }

  2332.                 f->padding -= f->last - f->pos;

  2334.                 break;
  2335.             }

  2337.             if (f->pos + f->padding < f->last) {
  2338.                 f->state = ngx_http_fastcgi_st_version;
  2339.                 f->pos += f->padding;

  2341.                 continue;
  2342.             }

  2344.             if (f->pos + f->padding == f->last) {
  2345.                 f->state = ngx_http_fastcgi_st_version;

  2347.                 break;
  2348.             }

  2350.             f->padding -= f->last - f->pos;

  2352.             break;
  2353.         }


  2356.         /* f->state == ngx_http_fastcgi_st_data */

  2358.         if (f->type == NGX_HTTP_FASTCGI_STDERR) {

  2360.             if (f->length) {

  2362.                 if (f->pos == f->last) {
  2363.                     break;
  2364.                 }

  2366.                 msg = f->pos;

  2368.                 if (f->pos + f->length <= f->last) {
  2369.                     f->pos += f->length;
  2370.                     f->length = 0;
  2371.                     f->state = ngx_http_fastcgi_st_padding;

  2373.                 } else {
  2374.                     f->length -= f->last - f->pos;
  2375.                     f->pos = f->last;
  2376.                 }

  2378.                 for (m = f->pos - 1; msg < m; m--) {
  2379.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2380.                         break;
  2381.                     }
  2382.                 }

  2384.                 ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2385.                               "FastCGI sent in stderr: \"%*s\"",
  2386.                               m + 1 - msg, msg);

  2388.             } else {
  2389.                 f->state = ngx_http_fastcgi_st_padding;
  2390.             }

  2392.             continue;
  2393.         }

  2395.         if (f->type == NGX_HTTP_FASTCGI_END_REQUEST) {

  2397.             if (f->pos + f->length <= f->last) {
  2398.                 f->state = ngx_http_fastcgi_st_padding;
  2399.                 f->pos += f->length;

  2401.                 continue;
  2402.             }

  2404.             f->length -= f->last - f->pos;

  2406.             break;
  2407.         }


  2410.         /* f->type == NGX_HTTP_FASTCGI_STDOUT */

  2412.         if (f->pos == f->last) {
  2413.             break;
  2414.         }

  2416.         if (f->rest == -2) {
  2417.             f->rest = r->upstream->headers_in.content_length_n;
  2418.         }

  2420.         if (f->rest == 0) {
  2421.             ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2422.                           "upstream sent more data than specified in "
  2423.                           "\"Content-Length\" header");
  2424.             p->upstream_done = 1;
  2425.             break;
  2426.         }

  2428.         cl = ngx_chain_get_free_buf(p->pool, &p->free);
  2429.         if (cl == NULL) {
  2430.             return NGX_ERROR;
  2431.         }

  2433.         b = cl->buf;

  2435.         ngx_memzero(b, sizeof(ngx_buf_t));

  2437.         b->pos = f->pos;
  2438.         b->start = buf->start;
  2439.         b->end = buf->end;
  2440.         b->tag = p->tag;
  2441.         b->temporary = 1;
  2442.         b->recycled = 1;

  2444.         *prev = b;
  2445.         prev = &b->shadow;

  2447.         if (p->in) {
  2448.             *p->last_in = cl;
  2449.         } else {
  2450.             p->in = cl;
  2451.         }
  2452.         p->last_in = &cl->next;


  2455.         /* STUB */ b->num = buf->num;

  2457.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, p->log, 0,
  2458.                        "input buf #%d %p", b->num, b->pos);

  2460.         if (f->pos + f->length <= f->last) {
  2461.             f->state = ngx_http_fastcgi_st_padding;
  2462.             f->pos += f->length;
  2463.             b->last = f->pos;

  2465.         } else {
  2466.             f->length -= f->last - f->pos;
  2467.             f->pos = f->last;
  2468.             b->last = f->last;
  2469.         }

  2471.         if (f->rest > 0) {

  2473.             if (b->last - b->pos > f->rest) {
  2474.                 ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2475.                               "upstream sent more data than specified in "
  2476.                               "\"Content-Length\" header");

  2478.                 b->last = b->pos + f->rest;
  2479.                 p->upstream_done = 1;

  2481.                 break;
  2482.             }

  2484.             f->rest -= b->last - b->pos;
  2485.         }
  2486.     }

  2488.     if (flcf->keep_conn) {

  2490.         /* set p->length, minimal amount of data we want to see */

  2492.         if (f->state < ngx_http_fastcgi_st_data) {
  2493.             p->length = 1;

  2495.         } else if (f->state == ngx_http_fastcgi_st_padding) {
  2496.             p->length = f->padding;

  2498.         } else {
  2499.             /* ngx_http_fastcgi_st_data */

  2501.             p->length = f->length;
  2502.         }
  2503.     }

  2505.     if (b) {
  2506.         b->shadow = buf;
  2507.         b->last_shadow = 1;

  2509.         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, p->log, 0,
  2510.                        "input buf %p %z", b->pos, b->last - b->pos);

  2512.         return NGX_OK;
  2513.     }

  2515.     /* there is no data record in the buf, add it to free chain */

  2517.     if (ngx_event_pipe_add_free_buf(p, buf) != NGX_OK) {
  2518.         return NGX_ERROR;
  2519.     }

  2521.     return NGX_OK;
  2522. }


  2525. static ngx_int_t
  2526. ‌ngx_http_fastcgi_non_buffered_filter(void *data, ssize_t bytes)
  2527. {
  2528.     u_char                  *m, *msg;
  2529.     ngx_int_t                rc;
  2530.     ngx_buf_t               *b, *buf;
  2531.     ngx_chain_t             *cl, **ll;
  2532.     ngx_http_request_t      *r;
  2533.     ngx_http_upstream_t     *u;
  2534.     ngx_http_fastcgi_ctx_t  *f;

  2536.     r = data;
  2537.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  2539.     u = r->upstream;
  2540.     buf = &u->buffer;

  2542.     buf->pos = buf->last;
  2543.     buf->last += bytes;

  2545.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2546.         ll = &cl->next;
  2547.     }

  2549.     f->pos = buf->pos;
  2550.     f->last = buf->last;

  2552.     for ( ;; ) {
  2553.         if (f->state < ngx_http_fastcgi_st_data) {

  2555.             rc = ngx_http_fastcgi_process_record(r, f);

  2557.             if (rc == NGX_AGAIN) {
  2558.                 break;
  2559.             }

  2561.             if (rc == NGX_ERROR) {
  2562.                 return NGX_ERROR;
  2563.             }

  2565.             if (f->type == NGX_HTTP_FASTCGI_STDOUT && f->length == 0) {
  2566.                 f->state = ngx_http_fastcgi_st_padding;

  2568.                 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2569.                                "http fastcgi closed stdout");

  2571.                 continue;
  2572.             }
  2573.         }

  2575.         if (f->state == ngx_http_fastcgi_st_padding) {

  2577.             if (f->type == NGX_HTTP_FASTCGI_END_REQUEST) {

  2579.                 if (f->rest > 0) {
  2580.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2581.                                   "upstream prematurely closed "
  2582.                                   "FastCGI request");
  2583.                     u->error = 1;
  2584.                     break;
  2585.                 }

  2587.                 if (f->pos + f->padding < f->last) {
  2588.                     u->length = 0;
  2589.                     break;
  2590.                 }

  2592.                 if (f->pos + f->padding == f->last) {
  2593.                     u->length = 0;
  2594.                     u->keepalive = 1;
  2595.                     break;
  2596.                 }

  2598.                 f->padding -= f->last - f->pos;

  2600.                 break;
  2601.             }

  2603.             if (f->pos + f->padding < f->last) {
  2604.                 f->state = ngx_http_fastcgi_st_version;
  2605.                 f->pos += f->padding;

  2607.                 continue;
  2608.             }

  2610.             if (f->pos + f->padding == f->last) {
  2611.                 f->state = ngx_http_fastcgi_st_version;

  2613.                 break;
  2614.             }

  2616.             f->padding -= f->last - f->pos;

  2618.             break;
  2619.         }


  2622.         /* f->state == ngx_http_fastcgi_st_data */

  2624.         if (f->type == NGX_HTTP_FASTCGI_STDERR) {

  2626.             if (f->length) {

  2628.                 if (f->pos == f->last) {
  2629.                     break;
  2630.                 }

  2632.                 msg = f->pos;

  2634.                 if (f->pos + f->length <= f->last) {
  2635.                     f->pos += f->length;
  2636.                     f->length = 0;
  2637.                     f->state = ngx_http_fastcgi_st_padding;

  2639.                 } else {
  2640.                     f->length -= f->last - f->pos;
  2641.                     f->pos = f->last;
  2642.                 }

  2644.                 for (m = f->pos - 1; msg < m; m--) {
  2645.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2646.                         break;
  2647.                     }
  2648.                 }

  2650.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2651.                               "FastCGI sent in stderr: \"%*s\"",
  2652.                               m + 1 - msg, msg);

  2654.             } else {
  2655.                 f->state = ngx_http_fastcgi_st_padding;
  2656.             }

  2658.             continue;
  2659.         }

  2661.         if (f->type == NGX_HTTP_FASTCGI_END_REQUEST) {

  2663.             if (f->pos + f->length <= f->last) {
  2664.                 f->state = ngx_http_fastcgi_st_padding;
  2665.                 f->pos += f->length;

  2667.                 continue;
  2668.             }

  2670.             f->length -= f->last - f->pos;

  2672.             break;
  2673.         }


  2676.         /* f->type == NGX_HTTP_FASTCGI_STDOUT */

  2678.         if (f->pos == f->last) {
  2679.             break;
  2680.         }

  2682.         if (f->rest == 0) {
  2683.             ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  2684.                           "upstream sent more data than specified in "
  2685.                           "\"Content-Length\" header");
  2686.             u->length = 0;
  2687.             break;
  2688.         }

  2690.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2691.         if (cl == NULL) {
  2692.             return NGX_ERROR;
  2693.         }

  2695.         *ll = cl;
  2696.         ll = &cl->next;

  2698.         b = cl->buf;

  2700.         b->flush = 1;
  2701.         b->memory = 1;

  2703.         b->pos = f->pos;
  2704.         b->tag = u->output.tag;

  2706.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2707.                        "http fastcgi output buf %p", b->pos);

  2709.         if (f->pos + f->length <= f->last) {
  2710.             f->state = ngx_http_fastcgi_st_padding;
  2711.             f->pos += f->length;
  2712.             b->last = f->pos;

  2714.         } else {
  2715.             f->length -= f->last - f->pos;
  2716.             f->pos = f->last;
  2717.             b->last = f->last;
  2718.         }

  2720.         if (f->rest > 0) {

  2722.             if (b->last - b->pos > f->rest) {
  2723.                 ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  2724.                               "upstream sent more data than specified in "
  2725.                               "\"Content-Length\" header");

  2727.                 b->last = b->pos + f->rest;
  2728.                 u->length = 0;

  2730.                 break;
  2731.             }

  2733.             f->rest -= b->last - b->pos;
  2734.         }
  2735.     }

  2737.     return NGX_OK;
  2738. }


  2741. static ngx_int_t
  2742. ‌ngx_http_fastcgi_process_record(ngx_http_request_t *r,
  2743.     ngx_http_fastcgi_ctx_t *f)
  2744. {
  2745.     u_char                     ch, *p;
  2746.     ngx_http_fastcgi_state_e   state;

  2748.     state = f->state;

  2750.     for (p = f->pos; p < f->last; p++) {

  2752.         ch = *p;

  2754.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2755.                        "http fastcgi record byte: %02Xd", ch);

  2757.         switch (state) {

  2759.         case ngx_http_fastcgi_st_version:
  2760.             if (ch != 1) {
  2761.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2762.                               "upstream sent unsupported FastCGI "
  2763.                               "protocol version: %d", ch);
  2764.                 return NGX_ERROR;
  2765.             }
  2766.             state = ngx_http_fastcgi_st_type;
  2767.             break;

  2769.         case ngx_http_fastcgi_st_type:
  2770.             switch (ch) {
  2771.             case NGX_HTTP_FASTCGI_STDOUT:
  2772.             case NGX_HTTP_FASTCGI_STDERR:
  2773.             case NGX_HTTP_FASTCGI_END_REQUEST:
  2774.                 f->type = (ngx_uint_t) ch;
  2775.                 break;
  2776.             default:
  2777.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2778.                               "upstream sent invalid FastCGI "
  2779.                               "record type: %d", ch);
  2780.                 return NGX_ERROR;

  2782.             }
  2783.             state = ngx_http_fastcgi_st_request_id_hi;
  2784.             break;

  2786.         /* we support the single request per connection */

  2788.         case ngx_http_fastcgi_st_request_id_hi:
  2789.             if (ch != 0) {
  2790.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2791.                               "upstream sent unexpected FastCGI "
  2792.                               "request id high byte: %d", ch);
  2793.                 return NGX_ERROR;
  2794.             }
  2795.             state = ngx_http_fastcgi_st_request_id_lo;
  2796.             break;

  2798.         case ngx_http_fastcgi_st_request_id_lo:
  2799.             if (ch != 1) {
  2800.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2801.                               "upstream sent unexpected FastCGI "
  2802.                               "request id low byte: %d", ch);
  2803.                 return NGX_ERROR;
  2804.             }
  2805.             state = ngx_http_fastcgi_st_content_length_hi;
  2806.             break;

  2808.         case ngx_http_fastcgi_st_content_length_hi:
  2809.             f->length = ch << 8;
  2810.             state = ngx_http_fastcgi_st_content_length_lo;
  2811.             break;

  2813.         case ngx_http_fastcgi_st_content_length_lo:
  2814.             f->length |= (size_t) ch;
  2815.             state = ngx_http_fastcgi_st_padding_length;
  2816.             break;

  2818.         case ngx_http_fastcgi_st_padding_length:
  2819.             f->padding = (size_t) ch;
  2820.             state = ngx_http_fastcgi_st_reserved;
  2821.             break;

  2823.         case ngx_http_fastcgi_st_reserved:
  2824.             state = ngx_http_fastcgi_st_data;

  2826.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2827.                            "http fastcgi record length: %z", f->length);

  2829.             f->pos = p + 1;
  2830.             f->state = state;

  2832.             return NGX_OK;

  2834.         /* suppress warning */
  2835.         case ngx_http_fastcgi_st_data:
  2836.         case ngx_http_fastcgi_st_padding:
  2837.             break;
  2838.         }
  2839.     }

  2841.     f->pos = p;
  2842.     f->state = state;

  2844.     return NGX_AGAIN;
  2845. }


  2848. static void
  2849. ‌ngx_http_fastcgi_abort_request(ngx_http_request_t *r)
  2850. {
  2851.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2852.                    "abort http fastcgi request");

  2854.     return;
  2855. }


  2858. static void
  2859. ‌ngx_http_fastcgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2860. {
  2861.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2862.                    "finalize http fastcgi request");

  2864.     return;
  2865. }


  2868. static ngx_int_t
  2869. ‌ngx_http_fastcgi_add_variables(ngx_conf_t *cf)
  2870. {
  2871.     ngx_http_variable_t  *var, *v;

  2873.     for (v = ngx_http_fastcgi_vars; v->name.len; v++) {
  2874.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  2875.         if (var == NULL) {
  2876.             return NGX_ERROR;
  2877.         }

  2879.         var->get_handler = v->get_handler;
  2880.         var->data = v->data;
  2881.     }

  2883.     return NGX_OK;
  2884. }


  2887. static void *
  2888. ‌ngx_http_fastcgi_create_main_conf(ngx_conf_t *cf)
  2889. {
  2890.     ngx_http_fastcgi_main_conf_t  *conf;

  2892.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_main_conf_t));
  2893.     if (conf == NULL) {
  2894.         return NULL;
  2895.     }

  2897. #if (NGX_HTTP_CACHE)
  2898.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  2899.                        sizeof(ngx_http_file_cache_t *))
  2900.         != NGX_OK)
  2901.     {
  2902.         return NULL;
  2903.     }
  2904. #endif

  2906.     return conf;
  2907. }


  2910. static void *
  2911. ‌ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf)
  2912. {
  2913.     ngx_http_fastcgi_loc_conf_t  *conf;

  2915.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_loc_conf_t));
  2916.     if (conf == NULL) {
  2917.         return NULL;
  2918.     }

  2920.     /*
  2921.      * set by ngx_pcalloc():
  2922.      *
  2923.      *     conf->upstream.bufs.num = 0;
  2924.      *     conf->upstream.ignore_headers = 0;
  2925.      *     conf->upstream.next_upstream = 0;
  2926.      *     conf->upstream.cache_zone = NULL;
  2927.      *     conf->upstream.cache_use_stale = 0;
  2928.      *     conf->upstream.cache_methods = 0;
  2929.      *     conf->upstream.temp_path = NULL;
  2930.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  2931.      *     conf->upstream.store_lengths = NULL;
  2932.      *     conf->upstream.store_values = NULL;
  2933.      *
  2934.      *     conf->index = { 0, NULL };
  2935.      */

  2937.     conf->upstream.store = NGX_CONF_UNSET;
  2938.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  2939.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  2940.     conf->upstream.buffering = NGX_CONF_UNSET;
  2941.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  2942.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  2943.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  2945.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  2946.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  2947.     conf->upstream.socket_rcvbuf = NGX_CONF_UNSET_SIZE;
  2948.     conf->upstream.socket_sndbuf = NGX_CONF_UNSET_SIZE;

  2950.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  2951.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  2952.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  2953.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  2955.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  2956.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  2957.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  2959.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  2960.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  2961.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  2963.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  2964.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  2966. #if (NGX_HTTP_CACHE)
  2967.     conf->upstream.cache = NGX_CONF_UNSET;
  2968.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  2969.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  2970.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  2971.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  2972.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  2973.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  2974.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  2975.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  2976.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  2977.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  2978. #endif

  2980.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  2981.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  2983.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  2985.     /* "fastcgi_cyclic_temp_file" is disabled */
  2986.     conf->upstream.cyclic_temp_file = 0;

  2988.     conf->upstream.change_buffering = 1;

  2990.     conf->catch_stderr = NGX_CONF_UNSET_PTR;

  2992.     conf->keep_conn = NGX_CONF_UNSET;

  2994.     ngx_str_set(&conf->upstream.module, "fastcgi");

  2996.     return conf;
  2997. }


  3000. static char *
  3001. ‌ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  3002. {
  3003.     ngx_http_fastcgi_loc_conf_t *prev = parent;
  3004.     ngx_http_fastcgi_loc_conf_t *conf = child;

  3006.     size_t                        size;
  3007.     ngx_int_t                     rc;
  3008.     ngx_hash_init_t               hash;
  3009.     ngx_http_core_loc_conf_t     *clcf;

  3011. #if (NGX_HTTP_CACHE)

  3013.     if (conf->upstream.store > 0) {
  3014.         conf->upstream.cache = 0;
  3015.     }

  3017.     if (conf->upstream.cache > 0) {
  3018.         conf->upstream.store = 0;
  3019.     }

  3021. #endif

  3023.     if (conf->upstream.store == NGX_CONF_UNSET) {
  3024.         ngx_conf_merge_value(conf->upstream.store,
  3025.                               prev->upstream.store, 0);

  3027.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  3028.         conf->upstream.store_values = prev->upstream.store_values;
  3029.     }

  3031.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  3032.                               prev->upstream.store_access, 0600);

  3034.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  3035.                               prev->upstream.next_upstream_tries, 0);

  3037.     ngx_conf_merge_value(conf->upstream.buffering,
  3038.                               prev->upstream.buffering, 1);

  3040.     ngx_conf_merge_value(conf->upstream.request_buffering,
  3041.                               prev->upstream.request_buffering, 1);

  3043.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  3044.                               prev->upstream.ignore_client_abort, 0);

  3046.     ngx_conf_merge_value(conf->upstream.force_ranges,
  3047.                               prev->upstream.force_ranges, 0);

  3049.     ngx_conf_merge_ptr_value(conf->upstream.local,
  3050.                               prev->upstream.local, NULL);

  3052.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  3053.                               prev->upstream.socket_keepalive, 0);

  3055.     ngx_conf_merge_size_value(conf->upstream.socket_rcvbuf,
  3056.                               prev->upstream.socket_rcvbuf, 0);

  3058.     ngx_conf_merge_size_value(conf->upstream.socket_sndbuf,
  3059.                               prev->upstream.socket_sndbuf, 0);

  3061.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  3062.                               prev->upstream.connect_timeout, 60000);

  3064.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  3065.                               prev->upstream.send_timeout, 60000);

  3067.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  3068.                               prev->upstream.read_timeout, 60000);

  3070.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  3071.                               prev->upstream.next_upstream_timeout, 0);

  3073.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  3074.                               prev->upstream.send_lowat, 0);

  3076.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  3077.                               prev->upstream.buffer_size,
  3078.                               (size_t) ngx_pagesize);

  3080.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  3081.                               prev->upstream.limit_rate, NULL);


  3084.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  3085.                               8, ngx_pagesize);

  3087.     if (conf->upstream.bufs.num < 2) {
  3088.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3089.                            "there must be at least 2 \"fastcgi_buffers\"");
  3090.         return NGX_CONF_ERROR;
  3091.     }


  3094.     size = conf->upstream.buffer_size;
  3095.     if (size < conf->upstream.bufs.size) {
  3096.         size = conf->upstream.bufs.size;
  3097.     }


  3100.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  3101.                               prev->upstream.busy_buffers_size_conf,
  3102.                               NGX_CONF_UNSET_SIZE);

  3104.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  3105.         conf->upstream.busy_buffers_size = 2 * size;
  3106.     } else {
  3107.         conf->upstream.busy_buffers_size =
  3108.                                          conf->upstream.busy_buffers_size_conf;
  3109.     }

  3111.     if (conf->upstream.busy_buffers_size < size) {
  3112.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3113.              "\"fastcgi_busy_buffers_size\" must be equal to or greater than "
  3114.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3115.              "one of the \"fastcgi_buffers\"");

  3117.         return NGX_CONF_ERROR;
  3118.     }

  3120.     if (conf->upstream.busy_buffers_size
  3121.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  3122.     {
  3123.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3124.              "\"fastcgi_busy_buffers_size\" must be less than "
  3125.              "the size of all \"fastcgi_buffers\" minus one buffer");

  3127.         return NGX_CONF_ERROR;
  3128.     }


  3131.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  3132.                               prev->upstream.temp_file_write_size_conf,
  3133.                               NGX_CONF_UNSET_SIZE);

  3135.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  3136.         conf->upstream.temp_file_write_size = 2 * size;
  3137.     } else {
  3138.         conf->upstream.temp_file_write_size =
  3139.                                       conf->upstream.temp_file_write_size_conf;
  3140.     }

  3142.     if (conf->upstream.temp_file_write_size < size) {
  3143.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3144.              "\"fastcgi_temp_file_write_size\" must be equal to or greater "
  3145.              "than the maximum of the value of \"fastcgi_buffer_size\" and "
  3146.              "one of the \"fastcgi_buffers\"");

  3148.         return NGX_CONF_ERROR;
  3149.     }


  3152.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  3153.                               prev->upstream.max_temp_file_size_conf,
  3154.                               NGX_CONF_UNSET_SIZE);

  3156.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  3157.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  3158.     } else {
  3159.         conf->upstream.max_temp_file_size =
  3160.                                         conf->upstream.max_temp_file_size_conf;
  3161.     }

  3163.     if (conf->upstream.max_temp_file_size != 0
  3164.         && conf->upstream.max_temp_file_size < size)
  3165.     {
  3166.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3167.              "\"fastcgi_max_temp_file_size\" must be equal to zero to disable "
  3168.              "temporary files usage or must be equal to or greater than "
  3169.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3170.              "one of the \"fastcgi_buffers\"");

  3172.         return NGX_CONF_ERROR;
  3173.     }


  3176.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  3177.                               prev->upstream.ignore_headers,
  3178.                               NGX_CONF_BITMASK_SET);


  3181.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  3182.                               prev->upstream.next_upstream,
  3183.                               (NGX_CONF_BITMASK_SET
  3184.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  3185.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  3187.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  3188.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  3189.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  3190.     }

  3192.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  3193.                               prev->upstream.temp_path,
  3194.                               &ngx_http_fastcgi_temp_path)
  3195.         != NGX_CONF_OK)
  3196.     {
  3197.         return NGX_CONF_ERROR;
  3198.     }

  3200. #if (NGX_HTTP_CACHE)

  3202.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  3203.         ngx_conf_merge_value(conf->upstream.cache,
  3204.                               prev->upstream.cache, 0);

  3206.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  3207.         conf->upstream.cache_value = prev->upstream.cache_value;
  3208.     }

  3210.     if (conf->upstream.cache_zone && conf->upstream.cache_zone->data == NULL) {
  3211.         ngx_shm_zone_t  *shm_zone;

  3213.         shm_zone = conf->upstream.cache_zone;

  3215.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3216.                            "\"fastcgi_cache\" zone \"%V\" is unknown",
  3217.                            &shm_zone->shm.name);

  3219.         return NGX_CONF_ERROR;
  3220.     }

  3222.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  3223.                               prev->upstream.cache_min_uses, 1);

  3225.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  3226.                               prev->upstream.cache_max_range_offset,
  3227.                               NGX_MAX_OFF_T_VALUE);

  3229.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  3230.                               prev->upstream.cache_use_stale,
  3231.                               (NGX_CONF_BITMASK_SET
  3232.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  3234.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  3235.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  3236.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  3237.     }

  3239.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  3240.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  3241.     }

  3243.     if (conf->upstream.cache_methods == 0) {
  3244.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  3245.     }

  3247.     conf->upstream.cache_methods |= NGX_HTTP_GET|NGX_HTTP_HEAD;

  3249.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  3250.                              prev->upstream.cache_bypass, NULL);

  3252.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  3253.                              prev->upstream.no_cache, NULL);

  3255.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  3256.                              prev->upstream.cache_valid, NULL);

  3258.     if (conf->cache_key.value.data == NULL) {
  3259.         conf->cache_key = prev->cache_key;
  3260.     }

  3262.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  3263.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3264.                            "no \"fastcgi_cache_key\" for \"fastcgi_cache\"");
  3265.     }

  3267.     ngx_conf_merge_value(conf->upstream.cache_lock,
  3268.                               prev->upstream.cache_lock, 0);

  3270.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  3271.                               prev->upstream.cache_lock_timeout, 5000);

  3273.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  3274.                               prev->upstream.cache_lock_age, 5000);

  3276.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  3277.                               prev->upstream.cache_revalidate, 0);

  3279.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  3280.                               prev->upstream.cache_background_update, 0);

  3282. #endif

  3284.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  3285.                               prev->upstream.pass_request_headers, 1);
  3286.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  3287.                               prev->upstream.pass_request_body, 1);

  3289.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  3290.                               prev->upstream.intercept_errors, 0);

  3292.     ngx_conf_merge_ptr_value(conf->catch_stderr, prev->catch_stderr, NULL);

  3294.     ngx_conf_merge_value(conf->keep_conn, prev->keep_conn, 0);


  3297.     ngx_conf_merge_str_value(conf->index, prev->index, "");

  3299.     hash.max_size = 512;
  3300.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  3301.     hash.name = "fastcgi_hide_headers_hash";

  3303.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  3304.              &prev->upstream, ngx_http_fastcgi_hide_headers, &hash)
  3305.         != NGX_OK)
  3306.     {
  3307.         return NGX_CONF_ERROR;
  3308.     }

  3310.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3312.     if (clcf->noname
  3313.         && conf->upstream.upstream == NULL && conf->fastcgi_lengths == NULL)
  3314.     {
  3315.         conf->upstream.upstream = prev->upstream.upstream;
  3316.         conf->fastcgi_lengths = prev->fastcgi_lengths;
  3317.         conf->fastcgi_values = prev->fastcgi_values;
  3318.     }

  3320.     if (clcf->lmt_excpt && clcf->handler == NULL
  3321.         && (conf->upstream.upstream || conf->fastcgi_lengths))
  3322.     {
  3323.         clcf->handler = ngx_http_fastcgi_handler;
  3324.     }

  3326. #if (NGX_PCRE)
  3327.     if (conf->split_regex == NULL) {
  3328.         conf->split_regex = prev->split_regex;
  3329.         conf->split_name = prev->split_name;
  3330.     }
  3331. #endif

  3333.     if (conf->params_source == NULL) {
  3334.         conf->params = prev->params;
  3335. #if (NGX_HTTP_CACHE)
  3336.         conf->params_cache = prev->params_cache;
  3337. #endif
  3338.         conf->params_source = prev->params_source;
  3339.     }

  3341.     rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params,
  3342.                                       ngx_http_fastcgi_headers);
  3343.     if (rc != NGX_OK) {
  3344.         return NGX_CONF_ERROR;
  3345.     }

  3347. #if (NGX_HTTP_CACHE)

  3349.     if (conf->upstream.cache) {
  3350.         rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params_cache,
  3351.                                           ngx_http_fastcgi_cache_headers);
  3352.         if (rc != NGX_OK) {
  3353.             return NGX_CONF_ERROR;
  3354.         }
  3355.     }

  3357. #endif

  3359.     /*
  3360.      * special handling to preserve conf->params in the "http" section
  3361.      * to inherit it to all servers
  3362.      */

  3364.     if (prev->params.hash.buckets == NULL
  3365.         && conf->params_source == prev->params_source)
  3366.     {
  3367.         prev->params = conf->params;
  3368. #if (NGX_HTTP_CACHE)
  3369.         prev->params_cache = conf->params_cache;
  3370. #endif
  3371.     }

  3373.     return NGX_CONF_OK;
  3374. }


  3377. static ngx_int_t
  3378. ‌ngx_http_fastcgi_init_params(ngx_conf_t *cf, ngx_http_fastcgi_loc_conf_t *conf,
  3379.     ngx_http_fastcgi_params_t *params, ngx_keyval_t *default_params)
  3380. {
  3381.     u_char                       *p;
  3382.     size_t                        size;
  3383.     uintptr_t                    *code;
  3384.     ngx_uint_t                    i, nsrc;
  3385.     ngx_array_t                   headers_names, params_merged;
  3386.     ngx_keyval_t                 *h;
  3387.     ngx_hash_key_t               *hk;
  3388.     ngx_hash_init_t               hash;
  3389.     ngx_http_upstream_param_t    *src, *s;
  3390.     ngx_http_script_compile_t     sc;
  3391.     ngx_http_script_copy_code_t  *copy;

  3393.     if (params->hash.buckets) {
  3394.         return NGX_OK;
  3395.     }

  3397.     if (conf->params_source == NULL && default_params == NULL) {
  3398.         params->hash.buckets = (void *) 1;
  3399.         return NGX_OK;
  3400.     }

  3402.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  3403.     if (params->lengths == NULL) {
  3404.         return NGX_ERROR;
  3405.     }

  3407.     params->values = ngx_array_create(cf->pool, 512, 1);
  3408.     if (params->values == NULL) {
  3409.         return NGX_ERROR;
  3410.     }

  3412.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  3413.         != NGX_OK)
  3414.     {
  3415.         return NGX_ERROR;
  3416.     }

  3418.     if (conf->params_source) {
  3419.         src = conf->params_source->elts;
  3420.         nsrc = conf->params_source->nelts;

  3422.     } else {
  3423.         src = NULL;
  3424.         nsrc = 0;
  3425.     }

  3427.     if (default_params) {
  3428.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  3429.                            sizeof(ngx_http_upstream_param_t))
  3430.             != NGX_OK)
  3431.         {
  3432.             return NGX_ERROR;
  3433.         }

  3435.         for (i = 0; i < nsrc; i++) {

  3437.             s = ngx_array_push(&params_merged);
  3438.             if (s == NULL) {
  3439.                 return NGX_ERROR;
  3440.             }

  3442.             *s = src[i];
  3443.         }

  3445.         h = default_params;

  3447.         while (h->key.len) {

  3449.             src = params_merged.elts;
  3450.             nsrc = params_merged.nelts;

  3452.             for (i = 0; i < nsrc; i++) {
  3453.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  3454.                     goto next;
  3455.                 }
  3456.             }

  3458.             s = ngx_array_push(&params_merged);
  3459.             if (s == NULL) {
  3460.                 return NGX_ERROR;
  3461.             }

  3463.             s->key = h->key;
  3464.             s->value = h->value;
  3465.             s->skip_empty = 1;

  3467.         next:

  3469.             h++;
  3470.         }

  3472.         src = params_merged.elts;
  3473.         nsrc = params_merged.nelts;
  3474.     }

  3476.     for (i = 0; i < nsrc; i++) {

  3478.         if (src[i].key.len > sizeof("HTTP_") - 1
  3479.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  3480.         {
  3481.             hk = ngx_array_push(&headers_names);
  3482.             if (hk == NULL) {
  3483.                 return NGX_ERROR;
  3484.             }

  3486.             hk->key.len = src[i].key.len - 5;
  3487.             hk->key.data = src[i].key.data + 5;
  3488.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  3489.             hk->value = (void *) 1;

  3491.             if (src[i].value.len == 0) {
  3492.                 continue;
  3493.             }
  3494.         }

  3496.         copy = ngx_array_push_n(params->lengths,
  3497.                                 sizeof(ngx_http_script_copy_code_t));
  3498.         if (copy == NULL) {
  3499.             return NGX_ERROR;
  3500.         }

  3502.         copy->code = (ngx_http_script_code_pt) (void *)
  3503.                                                  ngx_http_script_copy_len_code;
  3504.         copy->len = src[i].key.len;

  3506.         copy = ngx_array_push_n(params->lengths,
  3507.                                 sizeof(ngx_http_script_copy_code_t));
  3508.         if (copy == NULL) {
  3509.             return NGX_ERROR;
  3510.         }

  3512.         copy->code = (ngx_http_script_code_pt) (void *)
  3513.                                                  ngx_http_script_copy_len_code;
  3514.         copy->len = src[i].skip_empty;


  3517.         size = (sizeof(ngx_http_script_copy_code_t)
  3518.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  3519.                & ~(sizeof(uintptr_t) - 1);

  3521.         copy = ngx_array_push_n(params->values, size);
  3522.         if (copy == NULL) {
  3523.             return NGX_ERROR;
  3524.         }

  3526.         copy->code = ngx_http_script_copy_code;
  3527.         copy->len = src[i].key.len;

  3529.         p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
  3530.         ngx_memcpy(p, src[i].key.data, src[i].key.len);


  3533.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  3535.         sc.cf = cf;
  3536.         sc.source = &src[i].value;
  3537.         sc.flushes = &params->flushes;
  3538.         sc.lengths = &params->lengths;
  3539.         sc.values = &params->values;

  3541.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3542.             return NGX_ERROR;
  3543.         }

  3545.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3546.         if (code == NULL) {
  3547.             return NGX_ERROR;
  3548.         }

  3550.         *code = (uintptr_t) NULL;


  3553.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  3554.         if (code == NULL) {
  3555.             return NGX_ERROR;
  3556.         }

  3558.         *code = (uintptr_t) NULL;
  3559.     }

  3561.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3562.     if (code == NULL) {
  3563.         return NGX_ERROR;
  3564.     }

  3566.     *code = (uintptr_t) NULL;

  3568.     params->number = headers_names.nelts;

  3570.     hash.hash = &params->hash;
  3571.     hash.key = ngx_hash_key_lc;
  3572.     hash.max_size = 512;
  3573.     hash.bucket_size = 64;
  3574.     hash.name = "fastcgi_params_hash";
  3575.     hash.pool = cf->pool;
  3576.     hash.temp_pool = NULL;

  3578.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  3579. }


  3582. static ngx_int_t
  3583. ‌ngx_http_fastcgi_script_name_variable(ngx_http_request_t *r,
  3584.     ngx_http_variable_value_t *v, uintptr_t data)
  3585. {
  3586.     u_char                       *p;
  3587.     ngx_http_fastcgi_ctx_t       *f;
  3588.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3590.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3592.     f = ngx_http_fastcgi_split(r, flcf);

  3594.     if (f == NULL) {
  3595.         return NGX_ERROR;
  3596.     }

  3598.     if (f->script_name.len == 0
  3599.         || f->script_name.data[f->script_name.len - 1] != '/')
  3600.     {
  3601.         v->len = f->script_name.len;
  3602.         v->valid = 1;
  3603.         v->no_cacheable = 0;
  3604.         v->not_found = 0;
  3605.         v->data = f->script_name.data;

  3607.         return NGX_OK;
  3608.     }

  3610.     v->len = f->script_name.len + flcf->index.len;

  3612.     v->data = ngx_pnalloc(r->pool, v->len);
  3613.     if (v->data == NULL) {
  3614.         return NGX_ERROR;
  3615.     }

  3617.     p = ngx_copy(v->data, f->script_name.data, f->script_name.len);
  3618.     ngx_memcpy(p, flcf->index.data, flcf->index.len);

  3620.     return NGX_OK;
  3621. }


  3624. static ngx_int_t
  3625. ‌ngx_http_fastcgi_path_info_variable(ngx_http_request_t *r,
  3626.     ngx_http_variable_value_t *v, uintptr_t data)
  3627. {
  3628.     ngx_http_fastcgi_ctx_t       *f;
  3629.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3631.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3633.     f = ngx_http_fastcgi_split(r, flcf);

  3635.     if (f == NULL) {
  3636.         return NGX_ERROR;
  3637.     }

  3639.     v->len = f->path_info.len;
  3640.     v->valid = 1;
  3641.     v->no_cacheable = 0;
  3642.     v->not_found = 0;
  3643.     v->data = f->path_info.data;

  3645.     return NGX_OK;
  3646. }


  3649. static ngx_http_fastcgi_ctx_t *
  3650. ‌ngx_http_fastcgi_split(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  3651. {
  3652.     ngx_http_fastcgi_ctx_t       *f;
  3653. #if (NGX_PCRE)
  3654.     ngx_int_t                     n;
  3655.     int                           captures[(1 + 2) * 3];

  3657.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3659.     if (f == NULL) {
  3660.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3661.         if (f == NULL) {
  3662.             return NULL;
  3663.         }

  3665.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3666.     }

  3668.     if (f->script_name.len) {
  3669.         return f;
  3670.     }

  3672.     if (flcf->split_regex == NULL) {
  3673.         f->script_name = r->uri;
  3674.         return f;
  3675.     }

  3677.     n = ngx_regex_exec(flcf->split_regex, &r->uri, captures, (1 + 2) * 3);

  3679.     if (n >= 0) { /* match */
  3680.         f->script_name.len = captures[3] - captures[2];
  3681.         f->script_name.data = r->uri.data + captures[2];

  3683.         f->path_info.len = captures[5] - captures[4];
  3684.         f->path_info.data = r->uri.data + captures[4];

  3686.         return f;
  3687.     }

  3689.     if (n == NGX_REGEX_NO_MATCHED) {
  3690.         f->script_name = r->uri;
  3691.         return f;
  3692.     }

  3694.     ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  3695.                   ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  3696.                   n, &r->uri, &flcf->split_name);
  3697.     return NULL;

  3699. #else

  3701.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3703.     if (f == NULL) {
  3704.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3705.         if (f == NULL) {
  3706.             return NULL;
  3707.         }

  3709.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3710.     }

  3712.     f->script_name = r->uri;

  3714.     return f;

  3716. #endif
  3717. }


  3720. static char *
  3721. ‌ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3722. {
  3723.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3725.     ngx_url_t                   u;
  3726.     ngx_str_t                  *value, *url;
  3727.     ngx_uint_t                  n;
  3728.     ngx_http_core_loc_conf_t   *clcf;
  3729.     ngx_http_script_compile_t   sc;

  3731.     if (flcf->upstream.upstream || flcf->fastcgi_lengths) {
  3732.         return "is duplicate";
  3733.     }

  3735.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3737.     clcf->handler = ngx_http_fastcgi_handler;

  3739.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  3740.         clcf->auto_redirect = 1;
  3741.     }

  3743.     value = cf->args->elts;

  3745.     url = &value[1];

  3747.     n = ngx_http_script_variables_count(url);

  3749.     if (n) {

  3751.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  3753.         sc.cf = cf;
  3754.         sc.source = url;
  3755.         sc.lengths = &flcf->fastcgi_lengths;
  3756.         sc.values = &flcf->fastcgi_values;
  3757.         sc.variables = n;
  3758.         sc.complete_lengths = 1;
  3759.         sc.complete_values = 1;

  3761.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3762.             return NGX_CONF_ERROR;
  3763.         }

  3765.         return NGX_CONF_OK;
  3766.     }

  3768.     ngx_memzero(&u, sizeof(ngx_url_t));

  3770.     u.url = value[1];
  3771.     u.no_resolve = 1;

  3773.     flcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  3774.     if (flcf->upstream.upstream == NULL) {
  3775.         return NGX_CONF_ERROR;
  3776.     }

  3778.     return NGX_CONF_OK;
  3779. }


  3782. static char *
  3783. ‌ngx_http_fastcgi_split_path_info(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3784. {
  3785. #if (NGX_PCRE)
  3786.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3788.     ngx_str_t            *value;
  3789.     ngx_regex_compile_t   rc;
  3790.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

  3792.     value = cf->args->elts;

  3794.     flcf->split_name = value[1];

  3796.     ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  3798.     rc.pattern = value[1];
  3799.     rc.pool = cf->pool;
  3800.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3801.     rc.err.data = errstr;

  3803.     if (ngx_regex_compile(&rc) != NGX_OK) {
  3804.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  3805.         return NGX_CONF_ERROR;
  3806.     }

  3808.     if (rc.captures != 2) {
  3809.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3810.                            "pattern \"%V\" must have 2 captures", &value[1]);
  3811.         return NGX_CONF_ERROR;
  3812.     }

  3814.     flcf->split_regex = rc.regex;

  3816.     return NGX_CONF_OK;

  3818. #else

  3820.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3821.                        "\"%V\" requires PCRE library", &cmd->name);
  3822.     return NGX_CONF_ERROR;

  3824. #endif
  3825. }


  3828. static char *
  3829. ‌ngx_http_fastcgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3830. {
  3831.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3833.     ngx_str_t                  *value;
  3834.     ngx_http_script_compile_t   sc;

  3836.     if (flcf->upstream.store != NGX_CONF_UNSET) {
  3837.         return "is duplicate";
  3838.     }

  3840.     value = cf->args->elts;

  3842.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3843.         flcf->upstream.store = 0;
  3844.         return NGX_CONF_OK;
  3845.     }

  3847.     if (value[1].len == 0) {
  3848.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  3849.         return NGX_CONF_ERROR;
  3850.     }

  3852. #if (NGX_HTTP_CACHE)
  3853.     if (flcf->upstream.cache > 0) {
  3854.         return "is incompatible with \"fastcgi_cache\"";
  3855.     }
  3856. #endif

  3858.     flcf->upstream.store = 1;

  3860.     if (ngx_strcmp(value[1].data, "on") == 0) {
  3861.         return NGX_CONF_OK;
  3862.     }

  3864.     /* include the terminating '\0' into script */
  3865.     value[1].len++;

  3867.     ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  3869.     sc.cf = cf;
  3870.     sc.source = &value[1];
  3871.     sc.lengths = &flcf->upstream.store_lengths;
  3872.     sc.values = &flcf->upstream.store_values;
  3873.     sc.variables = ngx_http_script_variables_count(&value[1]);
  3874.     sc.complete_lengths = 1;
  3875.     sc.complete_values = 1;

  3877.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  3878.         return NGX_CONF_ERROR;
  3879.     }

  3881.     return NGX_CONF_OK;
  3882. }


  3885. #if (NGX_HTTP_CACHE)

  3887. static char *
  3888. ‌ngx_http_fastcgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3889. {
  3890.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3892.     ngx_str_t                         *value;
  3893.     ngx_http_complex_value_t           cv;
  3894.     ngx_http_compile_complex_value_t   ccv;

  3896.     value = cf->args->elts;

  3898.     if (flcf->upstream.cache != NGX_CONF_UNSET) {
  3899.         return "is duplicate";
  3900.     }

  3902.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3903.         flcf->upstream.cache = 0;
  3904.         return NGX_CONF_OK;
  3905.     }

  3907.     if (flcf->upstream.store > 0) {
  3908.         return "is incompatible with \"fastcgi_store\"";
  3909.     }

  3911.     flcf->upstream.cache = 1;

  3913.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  3915.     ccv.cf = cf;
  3916.     ccv.value = &value[1];
  3917.     ccv.complex_value = &cv;

  3919.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3920.         return NGX_CONF_ERROR;
  3921.     }

  3923.     if (cv.lengths != NULL) {

  3925.         flcf->upstream.cache_value = ngx_palloc(cf->pool,
  3926.                                              sizeof(ngx_http_complex_value_t));
  3927.         if (flcf->upstream.cache_value == NULL) {
  3928.             return NGX_CONF_ERROR;
  3929.         }

  3931.         *flcf->upstream.cache_value = cv;

  3933.         return NGX_CONF_OK;
  3934.     }

  3936.     flcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  3937.                                                       &ngx_http_fastcgi_module);
  3938.     if (flcf->upstream.cache_zone == NULL) {
  3939.         return NGX_CONF_ERROR;
  3940.     }

  3942.     return NGX_CONF_OK;
  3943. }


  3946. static char *
  3947. ‌ngx_http_fastcgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3948. {
  3949.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3951.     ngx_str_t                         *value;
  3952.     ngx_http_compile_complex_value_t   ccv;

  3954.     value = cf->args->elts;

  3956.     if (flcf->cache_key.value.data) {
  3957.         return "is duplicate";
  3958.     }

  3960.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  3962.     ccv.cf = cf;
  3963.     ccv.value = &value[1];
  3964.     ccv.complex_value = &flcf->cache_key;

  3966.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3967.         return NGX_CONF_ERROR;
  3968.     }

  3970.     return NGX_CONF_OK;
  3971. }

  3973. #endif


  3976. static char *
  3977. ‌ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post, void *data)
  3978. {
  3979. #if (NGX_FREEBSD)
  3980.     ssize_t *np = data;

  3982.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  3983.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3984.                            "\"fastcgi_send_lowat\" must be less than %d "
  3985.                            "(sysctl net.inet.tcp.sendspace)",
  3986.                            ngx_freebsd_net_inet_tcp_sendspace);

  3988.         return NGX_CONF_ERROR;
  3989.     }

  3991. #elif !(NGX_HAVE_SO_SNDLOWAT)
  3992.     ssize_t *np = data;

  3994.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3995.                        "\"fastcgi_send_lowat\" is not supported, ignored");

  3997.     *np = 0;

  3999. #endif

  4001.     return NGX_CONF_OK;
  4002. }

One Level Up Top Level