One Level Up Top Level

src/http/modules/ngx_http_fastcgi_module.c - nginx source code

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_connect_timeout"),
  300.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  301.       ngx_conf_set_msec_slot,
  302.       NGX_HTTP_LOC_CONF_OFFSET,
  303.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.connect_timeout),
  304.       NULL },

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

  313.     { ngx_string("fastcgi_send_lowat"),
  314.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  315.       ngx_conf_set_size_slot,
  316.       NGX_HTTP_LOC_CONF_OFFSET,
  317.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.send_lowat),
  318.       &ngx_http_fastcgi_lowat_post },

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

  327.     { ngx_string("fastcgi_pass_request_headers"),
  328.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  329.       ngx_conf_set_flag_slot,
  330.       NGX_HTTP_LOC_CONF_OFFSET,
  331.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.pass_request_headers),
  332.       NULL },

  334.     { ngx_string("fastcgi_pass_request_body"),
  335.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  336.       ngx_conf_set_flag_slot,
  337.       NGX_HTTP_LOC_CONF_OFFSET,
  338.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.pass_request_body),
  339.       NULL },

  341.     { ngx_string("fastcgi_intercept_errors"),
  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.intercept_errors),
  346.       NULL },

  348.     { ngx_string("fastcgi_read_timeout"),
  349.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  350.       ngx_conf_set_msec_slot,
  351.       NGX_HTTP_LOC_CONF_OFFSET,
  352.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.read_timeout),
  353.       NULL },

  355.     { ngx_string("fastcgi_buffers"),
  356.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  357.       ngx_conf_set_bufs_slot,
  358.       NGX_HTTP_LOC_CONF_OFFSET,
  359.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.bufs),
  360.       NULL },

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

  369.     { ngx_string("fastcgi_force_ranges"),
  370.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  371.       ngx_conf_set_flag_slot,
  372.       NGX_HTTP_LOC_CONF_OFFSET,
  373.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.force_ranges),
  374.       NULL },

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

  383. #if (NGX_HTTP_CACHE)

  385.     { ngx_string("fastcgi_cache"),
  386.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  387.       ngx_http_fastcgi_cache,
  388.       NGX_HTTP_LOC_CONF_OFFSET,
  389.       0,
  390.       NULL },

  392.     { ngx_string("fastcgi_cache_key"),
  393.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  394.       ngx_http_fastcgi_cache_key,
  395.       NGX_HTTP_LOC_CONF_OFFSET,
  396.       0,
  397.       NULL },

  399.     { ngx_string("fastcgi_cache_path"),
  400.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  401.       ngx_http_file_cache_set_slot,
  402.       NGX_HTTP_MAIN_CONF_OFFSET,
  403.       offsetof(ngx_http_fastcgi_main_conf_t, caches),
  404.       &ngx_http_fastcgi_module },

  406.     { ngx_string("fastcgi_cache_bypass"),
  407.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  408.       ngx_http_set_predicate_slot,
  409.       NGX_HTTP_LOC_CONF_OFFSET,
  410.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_bypass),
  411.       NULL },

  413.     { ngx_string("fastcgi_no_cache"),
  414.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  415.       ngx_http_set_predicate_slot,
  416.       NGX_HTTP_LOC_CONF_OFFSET,
  417.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.no_cache),
  418.       NULL },

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

  427.     { ngx_string("fastcgi_cache_min_uses"),
  428.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  429.       ngx_conf_set_num_slot,
  430.       NGX_HTTP_LOC_CONF_OFFSET,
  431.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_min_uses),
  432.       NULL },

  434.     { ngx_string("fastcgi_cache_max_range_offset"),
  435.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  436.       ngx_conf_set_off_slot,
  437.       NGX_HTTP_LOC_CONF_OFFSET,
  438.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_max_range_offset),
  439.       NULL },

  441.     { ngx_string("fastcgi_cache_use_stale"),
  442.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  443.       ngx_conf_set_bitmask_slot,
  444.       NGX_HTTP_LOC_CONF_OFFSET,
  445.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_use_stale),
  446.       &ngx_http_fastcgi_next_upstream_masks },

  448.     { ngx_string("fastcgi_cache_methods"),
  449.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  450.       ngx_conf_set_bitmask_slot,
  451.       NGX_HTTP_LOC_CONF_OFFSET,
  452.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_methods),
  453.       &ngx_http_upstream_cache_method_mask },

  455.     { ngx_string("fastcgi_cache_lock"),
  456.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  457.       ngx_conf_set_flag_slot,
  458.       NGX_HTTP_LOC_CONF_OFFSET,
  459.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_lock),
  460.       NULL },

  462.     { ngx_string("fastcgi_cache_lock_timeout"),
  463.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  464.       ngx_conf_set_msec_slot,
  465.       NGX_HTTP_LOC_CONF_OFFSET,
  466.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_lock_timeout),
  467.       NULL },

  469.     { ngx_string("fastcgi_cache_lock_age"),
  470.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  471.       ngx_conf_set_msec_slot,
  472.       NGX_HTTP_LOC_CONF_OFFSET,
  473.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_lock_age),
  474.       NULL },

  476.     { ngx_string("fastcgi_cache_revalidate"),
  477.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  478.       ngx_conf_set_flag_slot,
  479.       NGX_HTTP_LOC_CONF_OFFSET,
  480.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_revalidate),
  481.       NULL },

  483.     { ngx_string("fastcgi_cache_background_update"),
  484.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  485.       ngx_conf_set_flag_slot,
  486.       NGX_HTTP_LOC_CONF_OFFSET,
  487.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.cache_background_update),
  488.       NULL },

  490. #endif

  492.     { ngx_string("fastcgi_temp_path"),
  493.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  494.       ngx_conf_set_path_slot,
  495.       NGX_HTTP_LOC_CONF_OFFSET,
  496.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.temp_path),
  497.       NULL },

  499.     { ngx_string("fastcgi_max_temp_file_size"),
  500.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  501.       ngx_conf_set_size_slot,
  502.       NGX_HTTP_LOC_CONF_OFFSET,
  503.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.max_temp_file_size_conf),
  504.       NULL },

  506.     { ngx_string("fastcgi_temp_file_write_size"),
  507.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  508.       ngx_conf_set_size_slot,
  509.       NGX_HTTP_LOC_CONF_OFFSET,
  510.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.temp_file_write_size_conf),
  511.       NULL },

  513.     { ngx_string("fastcgi_next_upstream"),
  514.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  515.       ngx_conf_set_bitmask_slot,
  516.       NGX_HTTP_LOC_CONF_OFFSET,
  517.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream),
  518.       &ngx_http_fastcgi_next_upstream_masks },

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

  527.     { ngx_string("fastcgi_next_upstream_timeout"),
  528.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  529.       ngx_conf_set_msec_slot,
  530.       NGX_HTTP_LOC_CONF_OFFSET,
  531.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.next_upstream_timeout),
  532.       NULL },

  534.     { ngx_string("fastcgi_param"),
  535.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  536.       ngx_http_upstream_param_set_slot,
  537.       NGX_HTTP_LOC_CONF_OFFSET,
  538.       offsetof(ngx_http_fastcgi_loc_conf_t, params_source),
  539.       NULL },

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

  548.     { ngx_string("fastcgi_hide_header"),
  549.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  550.       ngx_conf_set_str_array_slot,
  551.       NGX_HTTP_LOC_CONF_OFFSET,
  552.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.hide_headers),
  553.       NULL },

  555.     { ngx_string("fastcgi_ignore_headers"),
  556.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  557.       ngx_conf_set_bitmask_slot,
  558.       NGX_HTTP_LOC_CONF_OFFSET,
  559.       offsetof(ngx_http_fastcgi_loc_conf_t, upstream.ignore_headers),
  560.       &ngx_http_upstream_ignore_headers_masks },

  562.     { ngx_string("fastcgi_catch_stderr"),
  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, catch_stderr),
  567.       NULL },

  569.     { ngx_string("fastcgi_keep_conn"),
  570.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  571.       ngx_conf_set_flag_slot,
  572.       NGX_HTTP_LOC_CONF_OFFSET,
  573.       offsetof(ngx_http_fastcgi_loc_conf_t, keep_conn),
  574.       NULL },

  576.       ngx_null_command
  577. };


  580. ‌static ngx_http_module_t  ngx_http_fastcgi_module_ctx = {
  581.     ngx_http_fastcgi_add_variables,        /* preconfiguration */
  582.     NULL,                                  /* postconfiguration */

  584.     ngx_http_fastcgi_create_main_conf,     /* create main configuration */
  585.     NULL,                                  /* init main configuration */

  587.     NULL,                                  /* create server configuration */
  588.     NULL,                                  /* merge server configuration */

  590.     ngx_http_fastcgi_create_loc_conf,      /* create location configuration */
  591.     ngx_http_fastcgi_merge_loc_conf        /* merge location configuration */
  592. };


  595. ‌ngx_module_t  ngx_http_fastcgi_module = {
  596.     NGX_MODULE_V1,
  597.     &ngx_http_fastcgi_module_ctx,          /* module context */
  598.     ngx_http_fastcgi_commands,             /* module directives */
  599.     NGX_HTTP_MODULE,                       /* module type */
  600.     NULL,                                  /* init master */
  601.     NULL,                                  /* init module */
  602.     NULL,                                  /* init process */
  603.     NULL,                                  /* init thread */
  604.     NULL,                                  /* exit thread */
  605.     NULL,                                  /* exit process */
  606.     NULL,                                  /* exit master */
  607.     NGX_MODULE_V1_PADDING
  608. };


  611. ‌static ngx_http_fastcgi_request_start_t  ngx_http_fastcgi_request_start = {
  612.     { 1,                                               /* version */
  613.       NGX_HTTP_FASTCGI_BEGIN_REQUEST,                  /* type */
  614.       0,                                               /* request_id_hi */
  615.       1,                                               /* request_id_lo */
  616.       0,                                               /* content_length_hi */
  617.       sizeof(ngx_http_fastcgi_begin_request_t),        /* content_length_lo */
  618.       0,                                               /* padding_length */
  619.       0 },                                             /* reserved */

  621.     { 0,                                               /* role_hi */
  622.       NGX_HTTP_FASTCGI_RESPONDER,                      /* role_lo */
  623.       0, /* NGX_HTTP_FASTCGI_KEEP_CONN */              /* flags */
  624.       { 0, 0, 0, 0, 0 } },                             /* reserved[5] */

  626.     { 1,                                               /* version */
  627.       NGX_HTTP_FASTCGI_PARAMS,                         /* type */
  628.       0,                                               /* request_id_hi */
  629.       1 },                                             /* request_id_lo */

  631. };


  634. ‌static ngx_http_variable_t  ngx_http_fastcgi_vars[] = {

  636.     { ngx_string("fastcgi_script_name"), NULL,
  637.       ngx_http_fastcgi_script_name_variable, 0,
  638.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  640.     { ngx_string("fastcgi_path_info"), NULL,
  641.       ngx_http_fastcgi_path_info_variable, 0,
  642.       NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },

  644.       ngx_http_null_variable
  645. };


  648. ‌static ngx_str_t  ngx_http_fastcgi_hide_headers[] = {
  649.     ngx_string("Status"),
  650.     ngx_string("X-Accel-Expires"),
  651.     ngx_string("X-Accel-Redirect"),
  652.     ngx_string("X-Accel-Limit-Rate"),
  653.     ngx_string("X-Accel-Buffering"),
  654.     ngx_string("X-Accel-Charset"),
  655.     ngx_null_string
  656. };


  659. #if (NGX_HTTP_CACHE)

  661. ‌static ngx_keyval_t  ngx_http_fastcgi_cache_headers[] = {
  662.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  663.       ngx_string("$upstream_cache_last_modified") },
  664.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  665.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  666.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  667.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  668.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  669.     { ngx_null_string, ngx_null_string }
  670. };

  672. #endif


  675. ‌static ngx_path_init_t  ngx_http_fastcgi_temp_path = {
  676.     ngx_string(NGX_HTTP_FASTCGI_TEMP_PATH), { 1, 2, 0 }
  677. };


  680. static ngx_int_t
  681. ‌ngx_http_fastcgi_handler(ngx_http_request_t *r)
  682. {
  683.     ngx_int_t                      rc;
  684.     ngx_http_upstream_t           *u;
  685.     ngx_http_fastcgi_ctx_t        *f;
  686.     ngx_http_fastcgi_loc_conf_t   *flcf;
  687. #if (NGX_HTTP_CACHE)
  688.     ngx_http_fastcgi_main_conf_t  *fmcf;
  689. #endif

  691.     if (ngx_http_upstream_create(r) != NGX_OK) {
  692.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  693.     }

  695.     f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  696.     if (f == NULL) {
  697.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  698.     }

  700.     ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);

  702.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  704.     if (flcf->fastcgi_lengths) {
  705.         if (ngx_http_fastcgi_eval(r, flcf) != NGX_OK) {
  706.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  707.         }
  708.     }

  710.     u = r->upstream;

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

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

  717. #if (NGX_HTTP_CACHE)
  718.     fmcf = ngx_http_get_module_main_conf(r, ngx_http_fastcgi_module);

  720.     u->caches = &fmcf->caches;
  721.     u->create_key = ngx_http_fastcgi_create_key;
  722. #endif

  724.     u->create_request = ngx_http_fastcgi_create_request;
  725.     u->reinit_request = ngx_http_fastcgi_reinit_request;
  726.     u->process_header = ngx_http_fastcgi_process_header;
  727.     u->abort_request = ngx_http_fastcgi_abort_request;
  728.     u->finalize_request = ngx_http_fastcgi_finalize_request;
  729.     r->state = 0;

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

  733.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  734.     if (u->pipe == NULL) {
  735.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  736.     }

  738.     u->pipe->input_filter = ngx_http_fastcgi_input_filter;
  739.     u->pipe->input_ctx = r;

  741.     u->input_filter_init = ngx_http_fastcgi_input_filter_init;
  742.     u->input_filter = ngx_http_fastcgi_non_buffered_filter;
  743.     u->input_filter_ctx = r;

  745.     if (!flcf->upstream.request_buffering
  746.         && flcf->upstream.pass_request_body)
  747.     {
  748.         r->request_body_no_buffering = 1;
  749.     }

  751.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  753.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  754.         return rc;
  755.     }

  757.     return NGX_DONE;
  758. }


  761. static ngx_int_t
  762. ‌ngx_http_fastcgi_eval(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  763. {
  764.     ngx_url_t             url;
  765.     ngx_http_upstream_t  *u;

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

  769.     if (ngx_http_script_run(r, &url.url, flcf->fastcgi_lengths->elts, 0,
  770.                             flcf->fastcgi_values->elts)
  771.         == NULL)
  772.     {
  773.         return NGX_ERROR;
  774.     }

  776.     url.no_resolve = 1;

  778.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  779.         if (url.err) {
  780.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  781.                           "%s in upstream \"%V\"", url.err, &url.url);
  782.         }

  784.         return NGX_ERROR;
  785.     }

  787.     u = r->upstream;

  789.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  790.     if (u->resolved == NULL) {
  791.         return NGX_ERROR;
  792.     }

  794.     if (url.addrs) {
  795.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  796.         u->resolved->socklen = url.addrs[0].socklen;
  797.         u->resolved->name = url.addrs[0].name;
  798.         u->resolved->naddrs = 1;
  799.     }

  801.     u->resolved->host = url.host;
  802.     u->resolved->port = url.port;
  803.     u->resolved->no_port = url.no_port;

  805.     return NGX_OK;
  806. }


  809. #if (NGX_HTTP_CACHE)

  811. static ngx_int_t
  812. ‌ngx_http_fastcgi_create_key(ngx_http_request_t *r)
  813. {
  814.     ngx_str_t                    *key;
  815.     ngx_http_fastcgi_loc_conf_t  *flcf;

  817.     key = ngx_array_push(&r->cache->keys);
  818.     if (key == NULL) {
  819.         return NGX_ERROR;
  820.     }

  822.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  824.     if (ngx_http_complex_value(r, &flcf->cache_key, key) != NGX_OK) {
  825.         return NGX_ERROR;
  826.     }

  828.     return NGX_OK;
  829. }

  831. #endif


  834. static ngx_int_t
  835. ‌ngx_http_fastcgi_create_request(ngx_http_request_t *r)
  836. {
  837.     off_t                         file_pos;
  838.     u_char                        ch, sep, *pos, *lowcase_key;
  839.     size_t                        size, len, key_len, val_len, padding,
  840.                                   allocated;
  841.     ngx_uint_t                    i, n, next, hash, skip_empty, header_params;
  842.     ngx_buf_t                    *b;
  843.     ngx_chain_t                  *cl, *body;
  844.     ngx_list_part_t              *part;
  845.     ngx_table_elt_t              *header, *hn, **ignored;
  846.     ngx_http_upstream_t          *u;
  847.     ngx_http_script_code_pt       code;
  848.     ngx_http_script_engine_t      e, le;
  849.     ngx_http_fastcgi_header_t    *h;
  850.     ngx_http_fastcgi_params_t    *params;
  851.     ngx_http_fastcgi_loc_conf_t  *flcf;
  852.     ngx_http_script_len_code_pt   lcode;

  854.     len = 0;
  855.     header_params = 0;
  856.     ignored = NULL;

  858.     u = r->upstream;

  860.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  862. #if (NGX_HTTP_CACHE)
  863.     params = u->cacheable ? &flcf->params_cache : &flcf->params;
  864. #else
  865.     params = &flcf->params;
  866. #endif

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

  871.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  872.         le.flushed = 1;

  874.         le.ip = params->lengths->elts;
  875.         le.request = r;

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

  879.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  880.             key_len = lcode(&le);

  882.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  883.             skip_empty = lcode(&le);

  885.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  886.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  887.             }
  888.             le.ip += sizeof(uintptr_t);

  890.             if (skip_empty && val_len == 0) {
  891.                 continue;
  892.             }

  894.             len += 1 + key_len + ((val_len > 127) ? 4 : 1) + val_len;
  895.         }
  896.     }

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

  900.         allocated = 0;
  901.         lowcase_key = NULL;

  903.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  904.             return NGX_ERROR;
  905.         }

  907.         if (params->number || r->headers_in.multi) {
  908.             n = 0;
  909.             part = &r->headers_in.headers.part;

  911.             while (part) {
  912.                 n += part->nelts;
  913.                 part = part->next;
  914.             }

  916.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  917.             if (ignored == NULL) {
  918.                 return NGX_ERROR;
  919.             }
  920.         }

  922.         part = &r->headers_in.headers.part;
  923.         header = part->elts;

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

  927.             if (i >= part->nelts) {
  928.                 if (part->next == NULL) {
  929.                     break;
  930.                 }

  932.                 part = part->next;
  933.                 header = part->elts;
  934.                 i = 0;
  935.             }

  937.             for (n = 0; n < header_params; n++) {
  938.                 if (&header[i] == ignored[n]) {
  939.                     goto next_length;
  940.                 }
  941.             }

  943.             if (params->number) {
  944.                 if (allocated < header[i].key.len) {
  945.                     allocated = header[i].key.len + 16;
  946.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  947.                     if (lowcase_key == NULL) {
  948.                         return NGX_ERROR;
  949.                     }
  950.                 }

  952.                 hash = 0;

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

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

  960.                     } else if (ch == '-') {
  961.                         ch = '_';
  962.                     }

  964.                     hash = ngx_hash(hash, ch);
  965.                     lowcase_key[n] = ch;
  966.                 }

  968.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  969.                     ignored[header_params++] = &header[i];
  970.                     continue;
  971.                 }
  972.             }

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

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

  978.             for (hn = header[i].next; hn; hn = hn->next) {
  979.                 val_len += hn->value.len + 2;
  980.                 ignored[header_params++] = hn;
  981.             }

  983.             len += ((key_len > 127) ? 4 : 1) + key_len
  984.                    + ((val_len > 127) ? 4 : 1) + val_len;

  986.         next_length:

  988.             continue;
  989.         }
  990.     }


  993.     if (len > 65535) {
  994.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  995.                       "fastcgi request record is too big: %uz", len);
  996.         return NGX_ERROR;
  997.     }


  1000.     padding = 8 - len % 8;
  1001.     padding = (padding == 8) ? 0 : padding;


  1004.     size = sizeof(ngx_http_fastcgi_header_t)
  1005.            + sizeof(ngx_http_fastcgi_begin_request_t)

  1007.            + sizeof(ngx_http_fastcgi_header_t)  /* NGX_HTTP_FASTCGI_PARAMS */
  1008.            + len + padding
  1009.            + sizeof(ngx_http_fastcgi_header_t)  /* NGX_HTTP_FASTCGI_PARAMS */

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


  1014.     b = ngx_create_temp_buf(r->pool, size);
  1015.     if (b == NULL) {
  1016.         return NGX_ERROR;
  1017.     }

  1019.     cl = ngx_alloc_chain_link(r->pool);
  1020.     if (cl == NULL) {
  1021.         return NGX_ERROR;
  1022.     }

  1024.     cl->buf = b;

  1026.     ngx_http_fastcgi_request_start.br.flags =
  1027.         flcf->keep_conn ? NGX_HTTP_FASTCGI_KEEP_CONN : 0;

  1029.     ngx_memcpy(b->pos, &ngx_http_fastcgi_request_start,
  1030.                sizeof(ngx_http_fastcgi_request_start_t));

  1032.     h = (ngx_http_fastcgi_header_t *)
  1033.              (b->pos + sizeof(ngx_http_fastcgi_header_t)
  1034.                      + sizeof(ngx_http_fastcgi_begin_request_t));

  1036.     h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1037.     h->content_length_lo = (u_char) (len & 0xff);
  1038.     h->padding_length = (u_char) padding;
  1039.     h->reserved = 0;

  1041.     b->last = b->pos + sizeof(ngx_http_fastcgi_header_t)
  1042.                      + sizeof(ngx_http_fastcgi_begin_request_t)
  1043.                      + sizeof(ngx_http_fastcgi_header_t);


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

  1049.         e.ip = params->values->elts;
  1050.         e.pos = b->last;
  1051.         e.request = r;
  1052.         e.flushed = 1;

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

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

  1058.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1059.             key_len = (u_char) lcode(&le);

  1061.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1062.             skip_empty = lcode(&le);

  1064.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1065.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1066.             }
  1067.             le.ip += sizeof(uintptr_t);

  1069.             if (skip_empty && val_len == 0) {
  1070.                 e.skip = 1;

  1072.                 while (*(uintptr_t *) e.ip) {
  1073.                     code = *(ngx_http_script_code_pt *) e.ip;
  1074.                     code((ngx_http_script_engine_t *) &e);
  1075.                 }
  1076.                 e.ip += sizeof(uintptr_t);

  1078.                 e.skip = 0;

  1080.                 continue;
  1081.             }

  1083.             *e.pos++ = (u_char) key_len;

  1085.             if (val_len > 127) {
  1086.                 *e.pos++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1087.                 *e.pos++ = (u_char) ((val_len >> 16) & 0xff);
  1088.                 *e.pos++ = (u_char) ((val_len >> 8) & 0xff);
  1089.                 *e.pos++ = (u_char) (val_len & 0xff);

  1091.             } else {
  1092.                 *e.pos++ = (u_char) val_len;
  1093.             }

  1095.             while (*(uintptr_t *) e.ip) {
  1096.                 code = *(ngx_http_script_code_pt *) e.ip;
  1097.                 code((ngx_http_script_engine_t *) &e);
  1098.             }
  1099.             e.ip += sizeof(uintptr_t);

  1101.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1102.                            "fastcgi param: \"%*s: %*s\"",
  1103.                            key_len, e.pos - (key_len + val_len),
  1104.                            val_len, e.pos - val_len);
  1105.         }

  1107.         b->last = e.pos;
  1108.     }


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

  1113.         part = &r->headers_in.headers.part;
  1114.         header = part->elts;

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

  1118.             if (i >= part->nelts) {
  1119.                 if (part->next == NULL) {
  1120.                     break;
  1121.                 }

  1123.                 part = part->next;
  1124.                 header = part->elts;
  1125.                 i = 0;
  1126.             }

  1128.             for (n = 0; n < header_params; n++) {
  1129.                 if (&header[i] == ignored[n]) {
  1130.                     goto next_value;
  1131.                 }
  1132.             }

  1134.             key_len = sizeof("HTTP_") - 1 + header[i].key.len;
  1135.             if (key_len > 127) {
  1136.                 *b->last++ = (u_char) (((key_len >> 24) & 0x7f) | 0x80);
  1137.                 *b->last++ = (u_char) ((key_len >> 16) & 0xff);
  1138.                 *b->last++ = (u_char) ((key_len >> 8) & 0xff);
  1139.                 *b->last++ = (u_char) (key_len & 0xff);

  1141.             } else {
  1142.                 *b->last++ = (u_char) key_len;
  1143.             }

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

  1147.             for (hn = header[i].next; hn; hn = hn->next) {
  1148.                 val_len += hn->value.len + 2;
  1149.             }

  1151.             if (val_len > 127) {
  1152.                 *b->last++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1153.                 *b->last++ = (u_char) ((val_len >> 16) & 0xff);
  1154.                 *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1155.                 *b->last++ = (u_char) (val_len & 0xff);

  1157.             } else {
  1158.                 *b->last++ = (u_char) val_len;
  1159.             }

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

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

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

  1169.                 } else if (ch == '-') {
  1170.                     ch = '_';
  1171.                 }

  1173.                 *b->last++ = ch;
  1174.             }

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

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

  1181.                 if (header[i].key.len == sizeof("Cookie") - 1
  1182.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1183.                                        sizeof("Cookie") - 1)
  1184.                        == 0)
  1185.                 {
  1186.                     sep = ';';

  1188.                 } else {
  1189.                     sep = ',';
  1190.                 }

  1192.                 for (hn = header[i].next; hn; hn = hn->next) {
  1193.                     *b->last++ = sep;
  1194.                     *b->last++ = ' ';
  1195.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1196.                 }
  1197.             }

  1199.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1200.                            "fastcgi param: \"%*s: %*s\"",
  1201.                            key_len, b->last - (key_len + val_len),
  1202.                            val_len, b->last - val_len);
  1203.         next_value:

  1205.             continue;
  1206.         }
  1207.     }


  1210.     if (padding) {
  1211.         ngx_memzero(b->last, padding);
  1212.         b->last += padding;
  1213.     }


  1216.     h = (ngx_http_fastcgi_header_t *) b->last;
  1217.     b->last += sizeof(ngx_http_fastcgi_header_t);

  1219.     h->version = 1;
  1220.     h->type = NGX_HTTP_FASTCGI_PARAMS;
  1221.     h->request_id_hi = 0;
  1222.     h->request_id_lo = 1;
  1223.     h->content_length_hi = 0;
  1224.     h->content_length_lo = 0;
  1225.     h->padding_length = 0;
  1226.     h->reserved = 0;

  1228.     if (r->request_body_no_buffering) {

  1230.         u->request_bufs = cl;

  1232.         u->output.output_filter = ngx_http_fastcgi_body_output_filter;
  1233.         u->output.filter_ctx = r;

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

  1237.         body = u->request_bufs;
  1238.         u->request_bufs = cl;

  1240. #if (NGX_SUPPRESS_WARN)
  1241.         file_pos = 0;
  1242.         pos = NULL;
  1243. #endif

  1245.         while (body) {

  1247.             if (ngx_buf_special(body->buf)) {
  1248.                 body = body->next;
  1249.                 continue;
  1250.             }

  1252.             if (body->buf->in_file) {
  1253.                 file_pos = body->buf->file_pos;

  1255.             } else {
  1256.                 pos = body->buf->pos;
  1257.             }

  1259.             next = 0;

  1261.             do {
  1262.                 b = ngx_alloc_buf(r->pool);
  1263.                 if (b == NULL) {
  1264.                     return NGX_ERROR;
  1265.                 }

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

  1269.                 if (body->buf->in_file) {
  1270.                     b->file_pos = file_pos;
  1271.                     file_pos += 32 * 1024;

  1273.                     if (file_pos >= body->buf->file_last) {
  1274.                         file_pos = body->buf->file_last;
  1275.                         next = 1;
  1276.                     }

  1278.                     b->file_last = file_pos;
  1279.                     len = (ngx_uint_t) (file_pos - b->file_pos);

  1281.                 } else {
  1282.                     b->pos = pos;
  1283.                     b->start = pos;
  1284.                     pos += 32 * 1024;

  1286.                     if (pos >= body->buf->last) {
  1287.                         pos = body->buf->last;
  1288.                         next = 1;
  1289.                     }

  1291.                     b->last = pos;
  1292.                     len = (ngx_uint_t) (pos - b->pos);
  1293.                 }

  1295.                 padding = 8 - len % 8;
  1296.                 padding = (padding == 8) ? 0 : padding;

  1298.                 h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1299.                 cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1301.                 h->version = 1;
  1302.                 h->type = NGX_HTTP_FASTCGI_STDIN;
  1303.                 h->request_id_hi = 0;
  1304.                 h->request_id_lo = 1;
  1305.                 h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1306.                 h->content_length_lo = (u_char) (len & 0xff);
  1307.                 h->padding_length = (u_char) padding;
  1308.                 h->reserved = 0;

  1310.                 cl->next = ngx_alloc_chain_link(r->pool);
  1311.                 if (cl->next == NULL) {
  1312.                     return NGX_ERROR;
  1313.                 }

  1315.                 cl = cl->next;
  1316.                 cl->buf = b;

  1318.                 b = ngx_create_temp_buf(r->pool,
  1319.                                         sizeof(ngx_http_fastcgi_header_t)
  1320.                                         + padding);
  1321.                 if (b == NULL) {
  1322.                     return NGX_ERROR;
  1323.                 }

  1325.                 if (padding) {
  1326.                     ngx_memzero(b->last, padding);
  1327.                     b->last += padding;
  1328.                 }

  1330.                 cl->next = ngx_alloc_chain_link(r->pool);
  1331.                 if (cl->next == NULL) {
  1332.                     return NGX_ERROR;
  1333.                 }

  1335.                 cl = cl->next;
  1336.                 cl->buf = b;

  1338.             } while (!next);

  1340.             body = body->next;
  1341.         }

  1343.     } else {
  1344.         u->request_bufs = cl;
  1345.     }

  1347.     if (!r->request_body_no_buffering) {
  1348.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1349.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1351.         h->version = 1;
  1352.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1353.         h->request_id_hi = 0;
  1354.         h->request_id_lo = 1;
  1355.         h->content_length_hi = 0;
  1356.         h->content_length_lo = 0;
  1357.         h->padding_length = 0;
  1358.         h->reserved = 0;
  1359.     }

  1361.     cl->next = NULL;

  1363.     return NGX_OK;
  1364. }


  1367. static ngx_int_t
  1368. ‌ngx_http_fastcgi_reinit_request(ngx_http_request_t *r)
  1369. {
  1370.     ngx_http_fastcgi_ctx_t  *f;

  1372.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1374.     if (f == NULL) {
  1375.         return NGX_OK;
  1376.     }

  1378.     f->state = ngx_http_fastcgi_st_version;
  1379.     f->fastcgi_stdout = 0;
  1380.     f->large_stderr = 0;

  1382.     if (f->split_parts) {
  1383.         f->split_parts->nelts = 0;
  1384.     }

  1386.     r->state = 0;

  1388.     return NGX_OK;
  1389. }


  1392. static ngx_int_t
  1393. ‌ngx_http_fastcgi_body_output_filter(void *data, ngx_chain_t *in)
  1394. {
  1395.     ngx_http_request_t  *r = data;

  1397.     off_t                       file_pos;
  1398.     u_char                     *pos, *start;
  1399.     size_t                      len, padding;
  1400.     ngx_buf_t                  *b;
  1401.     ngx_int_t                   rc;
  1402.     ngx_uint_t                  next, last;
  1403.     ngx_chain_t                *cl, *tl, *out, **ll;
  1404.     ngx_http_fastcgi_ctx_t     *f;
  1405.     ngx_http_fastcgi_header_t  *h;

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

  1410.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1412.     if (in == NULL) {
  1413.         out = in;
  1414.         goto out;
  1415.     }

  1417.     out = NULL;
  1418.     ll = &out;

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

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

  1426.         f->header_sent = 1;

  1428.         tl = ngx_alloc_chain_link(r->pool);
  1429.         if (tl == NULL) {
  1430.             return NGX_ERROR;
  1431.         }

  1433.         tl->buf = in->buf;
  1434.         *ll = tl;
  1435.         ll = &tl->next;

  1437.         in = in->next;

  1439.         if (in == NULL) {
  1440.             tl->next = NULL;
  1441.             goto out;
  1442.         }
  1443.     }

  1445.     cl = ngx_chain_get_free_buf(r->pool, &f->free);
  1446.     if (cl == NULL) {
  1447.         return NGX_ERROR;
  1448.     }

  1450.     b = cl->buf;

  1452.     b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1453.     b->temporary = 1;

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

  1458.         b->start = ngx_palloc(r->pool,
  1459.                               sizeof(ngx_http_fastcgi_header_t) + 7);
  1460.         if (b->start == NULL) {
  1461.             return NGX_ERROR;
  1462.         }

  1464.         b->pos = b->start;
  1465.         b->last = b->start;

  1467.         b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1468.     }

  1470.     *ll = cl;

  1472.     last = 0;
  1473.     padding = 0;

  1475. #if (NGX_SUPPRESS_WARN)
  1476.     file_pos = 0;
  1477.     pos = NULL;
  1478. #endif

  1480.     while (in) {

  1482.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1483.                        "fastcgi output in  l:%d f:%d %p, pos %p, size: %z "
  1484.                        "file: %O, size: %O",
  1485.                        in->buf->last_buf,
  1486.                        in->buf->in_file,
  1487.                        in->buf->start, in->buf->pos,
  1488.                        in->buf->last - in->buf->pos,
  1489.                        in->buf->file_pos,
  1490.                        in->buf->file_last - in->buf->file_pos);

  1492.         if (in->buf->last_buf) {
  1493.             last = 1;
  1494.         }

  1496.         if (ngx_buf_special(in->buf)) {
  1497.             in = in->next;
  1498.             continue;
  1499.         }

  1501.         if (in->buf->in_file) {
  1502.             file_pos = in->buf->file_pos;

  1504.         } else {
  1505.             pos = in->buf->pos;
  1506.         }

  1508.         next = 0;

  1510.         do {
  1511.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1512.             if (tl == NULL) {
  1513.                 return NGX_ERROR;
  1514.             }

  1516.             b = tl->buf;
  1517.             start = b->start;

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

  1521.             /*
  1522.              * restore b->start to preserve memory allocated in the buffer,
  1523.              * to reuse it later for headers and padding
  1524.              */

  1526.             b->start = start;

  1528.             if (in->buf->in_file) {
  1529.                 b->file_pos = file_pos;
  1530.                 file_pos += 32 * 1024;

  1532.                 if (file_pos >= in->buf->file_last) {
  1533.                     file_pos = in->buf->file_last;
  1534.                     next = 1;
  1535.                 }

  1537.                 b->file_last = file_pos;
  1538.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1540.             } else {
  1541.                 b->pos = pos;
  1542.                 pos += 32 * 1024;

  1544.                 if (pos >= in->buf->last) {
  1545.                     pos = in->buf->last;
  1546.                     next = 1;
  1547.                 }

  1549.                 b->last = pos;
  1550.                 len = (ngx_uint_t) (pos - b->pos);
  1551.             }

  1553.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1554.             b->shadow = in->buf;
  1555.             b->last_shadow = next;

  1557.             b->last_buf = 0;
  1558.             b->last_in_chain = 0;

  1560.             padding = 8 - len % 8;
  1561.             padding = (padding == 8) ? 0 : padding;

  1563.             h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1564.             cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1566.             h->version = 1;
  1567.             h->type = NGX_HTTP_FASTCGI_STDIN;
  1568.             h->request_id_hi = 0;
  1569.             h->request_id_lo = 1;
  1570.             h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1571.             h->content_length_lo = (u_char) (len & 0xff);
  1572.             h->padding_length = (u_char) padding;
  1573.             h->reserved = 0;

  1575.             cl->next = tl;
  1576.             cl = tl;

  1578.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1579.             if (tl == NULL) {
  1580.                 return NGX_ERROR;
  1581.             }

  1583.             b = tl->buf;

  1585.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1586.             b->temporary = 1;

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

  1591.                 b->start = ngx_palloc(r->pool,
  1592.                                       sizeof(ngx_http_fastcgi_header_t) + 7);
  1593.                 if (b->start == NULL) {
  1594.                     return NGX_ERROR;
  1595.                 }

  1597.                 b->pos = b->start;
  1598.                 b->last = b->start;

  1600.                 b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1601.             }

  1603.             if (padding) {
  1604.                 ngx_memzero(b->last, padding);
  1605.                 b->last += padding;
  1606.             }

  1608.             cl->next = tl;
  1609.             cl = tl;

  1611.         } while (!next);

  1613.         in = in->next;
  1614.     }

  1616.     if (last) {
  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 = 0;
  1625.         h->content_length_lo = 0;
  1626.         h->padding_length = 0;
  1627.         h->reserved = 0;

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

  1631.     } else if (padding == 0) {
  1632.         /* TODO: do not allocate buffers instead */
  1633.         cl->buf->temporary = 0;
  1634.         cl->buf->sync = 1;
  1635.     }

  1637.     cl->next = NULL;

  1639. out:

  1641. #if (NGX_DEBUG)

  1643.     for (cl = out; cl; cl = cl->next) {
  1644.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1645.                        "fastcgi output out l:%d f:%d %p, pos %p, size: %z "
  1646.                        "file: %O, size: %O",
  1647.                        cl->buf->last_buf,
  1648.                        cl->buf->in_file,
  1649.                        cl->buf->start, cl->buf->pos,
  1650.                        cl->buf->last - cl->buf->pos,
  1651.                        cl->buf->file_pos,
  1652.                        cl->buf->file_last - cl->buf->file_pos);
  1653.     }

  1655. #endif

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

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

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

  1664.         /* mark original buffers as sent */

  1666.         if (cl->buf->shadow) {
  1667.             if (cl->buf->last_shadow) {
  1668.                 b = cl->buf->shadow;
  1669.                 b->pos = b->last;
  1670.             }

  1672.             cl->buf->shadow = NULL;
  1673.         }
  1674.     }

  1676.     return rc;
  1677. }


  1680. static ngx_int_t
  1681. ‌ngx_http_fastcgi_process_header(ngx_http_request_t *r)
  1682. {
  1683.     u_char                         *p, *msg, *start, *last,
  1684.                                    *part_start, *part_end;
  1685.     size_t                          size;
  1686.     ngx_str_t                      *status_line, *pattern;
  1687.     ngx_int_t                       rc, status;
  1688.     ngx_buf_t                       buf;
  1689.     ngx_uint_t                      i;
  1690.     ngx_table_elt_t                *h;
  1691.     ngx_http_upstream_t            *u;
  1692.     ngx_http_fastcgi_ctx_t         *f;
  1693.     ngx_http_upstream_header_t     *hh;
  1694.     ngx_http_fastcgi_loc_conf_t    *flcf;
  1695.     ngx_http_fastcgi_split_part_t  *part;
  1696.     ngx_http_upstream_main_conf_t  *umcf;

  1698.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1700.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1702.     u = r->upstream;

  1704.     for ( ;; ) {

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

  1708.             f->pos = u->buffer.pos;
  1709.             f->last = u->buffer.last;

  1711.             rc = ngx_http_fastcgi_process_record(r, f);

  1713.             u->buffer.pos = f->pos;
  1714.             u->buffer.last = f->last;

  1716.             if (rc == NGX_AGAIN) {
  1717.                 return NGX_AGAIN;
  1718.             }

  1720.             if (rc == NGX_ERROR) {
  1721.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1722.             }

  1724.             if (f->type != NGX_HTTP_FASTCGI_STDOUT
  1725.                 && f->type != NGX_HTTP_FASTCGI_STDERR)
  1726.             {
  1727.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1728.                               "upstream sent unexpected FastCGI record: %ui",
  1729.                               f->type);

  1731.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1732.             }

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

  1738.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1739.             }
  1740.         }

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

  1744.             if (u->buffer.pos + f->padding < u->buffer.last) {
  1745.                 f->state = ngx_http_fastcgi_st_version;
  1746.                 u->buffer.pos += f->padding;

  1748.                 continue;
  1749.             }

  1751.             if (u->buffer.pos + f->padding == u->buffer.last) {
  1752.                 f->state = ngx_http_fastcgi_st_version;
  1753.                 u->buffer.pos = u->buffer.last;

  1755.                 return NGX_AGAIN;
  1756.             }

  1758.             f->padding -= u->buffer.last - u->buffer.pos;
  1759.             u->buffer.pos = u->buffer.last;

  1761.             return NGX_AGAIN;
  1762.         }


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

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

  1769.             if (f->length) {
  1770.                 msg = u->buffer.pos;

  1772.                 if (u->buffer.pos + f->length <= u->buffer.last) {
  1773.                     u->buffer.pos += f->length;
  1774.                     f->length = 0;
  1775.                     f->state = ngx_http_fastcgi_st_padding;

  1777.                 } else {
  1778.                     f->length -= u->buffer.last - u->buffer.pos;
  1779.                     u->buffer.pos = u->buffer.last;
  1780.                 }

  1782.                 for (p = u->buffer.pos - 1; msg < p; p--) {
  1783.                     if (*p != LF && *p != CR && *p != '.' && *p != ' ') {
  1784.                         break;
  1785.                     }
  1786.                 }

  1788.                 p++;

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

  1793.                 flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  1795.                 if (flcf->catch_stderr) {
  1796.                     pattern = flcf->catch_stderr->elts;

  1798.                     for (i = 0; i < flcf->catch_stderr->nelts; i++) {
  1799.                         if (ngx_strnstr(msg, (char *) pattern[i].data,
  1800.                                         p - msg)
  1801.                             != NULL)
  1802.                         {
  1803.                             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1804.                         }
  1805.                     }
  1806.                 }

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

  1810.                     if (!f->fastcgi_stdout) {

  1812.                         /*
  1813.                          * the special handling the large number
  1814.                          * of the PHP warnings to not allocate memory
  1815.                          */

  1817. #if (NGX_HTTP_CACHE)
  1818.                         if (r->cache) {
  1819.                             u->buffer.pos = u->buffer.start
  1820.                                                      + r->cache->header_start;
  1821.                         } else {
  1822.                             u->buffer.pos = u->buffer.start;
  1823.                         }
  1824. #else
  1825.                         u->buffer.pos = u->buffer.start;
  1826. #endif
  1827.                         u->buffer.last = u->buffer.pos;
  1828.                         f->large_stderr = 1;
  1829.                     }

  1831.                     return NGX_AGAIN;
  1832.                 }

  1834.             } else {
  1835.                 f->state = ngx_http_fastcgi_st_padding;
  1836.             }

  1838.             continue;
  1839.         }


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

  1844. #if (NGX_HTTP_CACHE)

  1846.         if (f->large_stderr && r->cache) {
  1847.             ssize_t                     len;
  1848.             ngx_http_fastcgi_header_t  *fh;

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

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

  1854.             /*
  1855.              * A tail of large stderr output before HTTP header is placed
  1856.              * in a cache file without a FastCGI record header.
  1857.              * To workaround it we put a dummy FastCGI record header at the
  1858.              * start of the stderr output or update r->cache_header_start,
  1859.              * if there is no enough place for the record header.
  1860.              */

  1862.             if (len >= 0) {
  1863.                 fh = (ngx_http_fastcgi_header_t *) start;
  1864.                 fh->version = 1;
  1865.                 fh->type = NGX_HTTP_FASTCGI_STDERR;
  1866.                 fh->request_id_hi = 0;
  1867.                 fh->request_id_lo = 1;
  1868.                 fh->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1869.                 fh->content_length_lo = (u_char) (len & 0xff);
  1870.                 fh->padding_length = 0;
  1871.                 fh->reserved = 0;

  1873.             } else {
  1874.                 r->cache->header_start += u->buffer.pos - start
  1875.                                           - sizeof(ngx_http_fastcgi_header_t);
  1876.             }

  1878.             f->large_stderr = 0;
  1879.         }

  1881. #endif

  1883.         f->fastcgi_stdout = 1;

  1885.         start = u->buffer.pos;

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

  1889.             /*
  1890.              * set u->buffer.last to the end of the FastCGI record data
  1891.              * for ngx_http_parse_header_line()
  1892.              */

  1894.             last = u->buffer.last;
  1895.             u->buffer.last = u->buffer.pos + f->length;

  1897.         } else {
  1898.             last = NULL;
  1899.         }

  1901.         for ( ;; ) {

  1903.             part_start = u->buffer.pos;
  1904.             part_end = u->buffer.last;

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

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

  1911.             if (rc == NGX_AGAIN) {
  1912.                 break;
  1913.             }

  1915.             if (rc == NGX_OK) {

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

  1919.                 h = ngx_list_push(&u->headers_in.headers);
  1920.                 if (h == NULL) {
  1921.                     return NGX_ERROR;
  1922.                 }

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

  1926.                     part = f->split_parts->elts;
  1927.                     size = u->buffer.pos - part_start;

  1929.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1930.                         size += part[i].end - part[i].start;
  1931.                     }

  1933.                     p = ngx_pnalloc(r->pool, size);
  1934.                     if (p == NULL) {
  1935.                         h->hash = 0;
  1936.                         return NGX_ERROR;
  1937.                     }

  1939.                     buf.pos = p;

  1941.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1942.                         p = ngx_cpymem(p, part[i].start,
  1943.                                        part[i].end - part[i].start);
  1944.                     }

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

  1948.                     buf.last = p;

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

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

  1954.                     if (rc != NGX_OK) {
  1955.                         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1956.                                       "invalid header after joining "
  1957.                                       "FastCGI records");
  1958.                         h->hash = 0;
  1959.                         return NGX_ERROR;
  1960.                     }

  1962.                     h->key.len = r->header_name_end - r->header_name_start;
  1963.                     h->key.data = r->header_name_start;
  1964.                     h->key.data[h->key.len] = '\0';

  1966.                     h->value.len = r->header_end - r->header_start;
  1967.                     h->value.data = r->header_start;
  1968.                     h->value.data[h->value.len] = '\0';

  1970.                     h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  1971.                     if (h->lowcase_key == NULL) {
  1972.                         return NGX_ERROR;
  1973.                     }

  1975.                 } else {

  1977.                     h->key.len = r->header_name_end - r->header_name_start;
  1978.                     h->value.len = r->header_end - r->header_start;

  1980.                     h->key.data = ngx_pnalloc(r->pool,
  1981.                                               h->key.len + 1 + h->value.len + 1
  1982.                                               + h->key.len);
  1983.                     if (h->key.data == NULL) {
  1984.                         h->hash = 0;
  1985.                         return NGX_ERROR;
  1986.                     }

  1988.                     h->value.data = h->key.data + h->key.len + 1;
  1989.                     h->lowcase_key = h->key.data + h->key.len + 1
  1990.                                      + h->value.len + 1;

  1992.                     ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1993.                     h->key.data[h->key.len] = '\0';
  1994.                     ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1995.                     h->value.data[h->value.len] = '\0';
  1996.                 }

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

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

  2003.                 } else {
  2004.                     ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  2005.                 }

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

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

  2013.                     if (rc != NGX_OK) {
  2014.                         return rc;
  2015.                     }
  2016.                 }

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

  2022.                 if (u->buffer.pos < u->buffer.last) {
  2023.                     continue;
  2024.                 }

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

  2028.                 break;
  2029.             }

  2031.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2038.                 if (u->headers_in.status) {
  2039.                     status_line = &u->headers_in.status->value;

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

  2043.                     if (status == NGX_ERROR) {
  2044.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2045.                                       "upstream sent invalid status \"%V\"",
  2046.                                       status_line);
  2047.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2048.                     }

  2050.                     u->headers_in.status_n = status;

  2052.                     if (status_line->len > 3) {
  2053.                         u->headers_in.status_line = *status_line;
  2054.                     }

  2056.                 } else if (u->headers_in.location) {
  2057.                     u->headers_in.status_n = 302;
  2058.                     ngx_str_set(&u->headers_in.status_line,
  2059.                                 "302 Moved Temporarily");

  2061.                 } else {
  2062.                     u->headers_in.status_n = 200;
  2063.                     ngx_str_set(&u->headers_in.status_line, "200 OK");
  2064.                 }

  2066.                 if (u->state && u->state->status == 0) {
  2067.                     u->state->status = u->headers_in.status_n;
  2068.                 }

  2070.                 break;
  2071.             }

  2073.             /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  2075.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2076.                           "upstream sent invalid header: \"%*s\\x%02xd...\"",
  2077.                           r->header_end - r->header_name_start,
  2078.                           r->header_name_start, *r->header_end);

  2080.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2081.         }

  2083.         if (last) {
  2084.             u->buffer.last = last;
  2085.         }

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

  2089.         if (f->length == 0) {
  2090.             f->state = ngx_http_fastcgi_st_padding;
  2091.         }

  2093.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2094.             return NGX_OK;
  2095.         }

  2097.         if (rc == NGX_OK) {
  2098.             continue;
  2099.         }

  2101.         /* rc == NGX_AGAIN */

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

  2106.         if (f->split_parts == NULL) {
  2107.             f->split_parts = ngx_array_create(r->pool, 1,
  2108.                                         sizeof(ngx_http_fastcgi_split_part_t));
  2109.             if (f->split_parts == NULL) {
  2110.                 return NGX_ERROR;
  2111.             }
  2112.         }

  2114.         part = ngx_array_push(f->split_parts);
  2115.         if (part == NULL) {
  2116.             return NGX_ERROR;
  2117.         }

  2119.         part->start = part_start;
  2120.         part->end = part_end;

  2122.         if (u->buffer.pos < u->buffer.last) {
  2123.             continue;
  2124.         }

  2126.         return NGX_AGAIN;
  2127.     }
  2128. }


  2131. static ngx_int_t
  2132. ‌ngx_http_fastcgi_input_filter_init(void *data)
  2133. {
  2134.     ngx_http_request_t  *r = data;

  2136.     ngx_http_upstream_t          *u;
  2137.     ngx_http_fastcgi_ctx_t       *f;
  2138.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2140.     u = r->upstream;

  2142.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2143.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

  2148.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  2149.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  2150.     {
  2151.         f->rest = 0;

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

  2156.     } else {
  2157.         f->rest = u->headers_in.content_length_n;
  2158.     }

  2160.     return NGX_OK;
  2161. }


  2164. static ngx_int_t
  2165. ‌ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
  2166. {
  2167.     u_char                       *m, *msg;
  2168.     ngx_int_t                     rc;
  2169.     ngx_buf_t                    *b, **prev;
  2170.     ngx_chain_t                  *cl;
  2171.     ngx_http_request_t           *r;
  2172.     ngx_http_fastcgi_ctx_t       *f;
  2173.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2175.     if (buf->pos == buf->last) {
  2176.         return NGX_OK;
  2177.     }

  2179.     r = p->input_ctx;
  2180.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2181.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

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

  2189.         return NGX_OK;
  2190.     }

  2192.     b = NULL;
  2193.     prev = &buf->shadow;

  2195.     f->pos = buf->pos;
  2196.     f->last = buf->last;

  2198.     for ( ;; ) {
  2199.         if (f->state < ngx_http_fastcgi_st_data) {

  2201.             rc = ngx_http_fastcgi_process_record(r, f);

  2203.             if (rc == NGX_AGAIN) {
  2204.                 break;
  2205.             }

  2207.             if (rc == NGX_ERROR) {
  2208.                 return NGX_ERROR;
  2209.             }

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

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

  2217.                 if (f->rest > 0) {
  2218.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2219.                                   "upstream prematurely closed "
  2220.                                   "FastCGI stdout");

  2222.                     p->upstream_error = 1;
  2223.                     p->upstream_eof = 0;
  2224.                     f->closed = 1;

  2226.                     break;
  2227.                 }

  2229.                 if (!flcf->keep_conn) {
  2230.                     p->upstream_done = 1;
  2231.                 }

  2233.                 continue;
  2234.             }

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

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

  2241.                 if (f->rest > 0) {
  2242.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2243.                                   "upstream prematurely closed "
  2244.                                   "FastCGI request");

  2246.                     p->upstream_error = 1;
  2247.                     p->upstream_eof = 0;
  2248.                     f->closed = 1;

  2250.                     break;
  2251.                 }

  2253.                 if (!flcf->keep_conn) {
  2254.                     p->upstream_done = 1;
  2255.                     break;
  2256.                 }

  2258.                 continue;
  2259.             }
  2260.         }


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

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

  2267.                 if (f->pos + f->padding < f->last) {
  2268.                     p->upstream_done = 1;
  2269.                     break;
  2270.                 }

  2272.                 if (f->pos + f->padding == f->last) {
  2273.                     p->upstream_done = 1;
  2274.                     r->upstream->keepalive = 1;
  2275.                     break;
  2276.                 }

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

  2280.                 break;
  2281.             }

  2283.             if (f->pos + f->padding < f->last) {
  2284.                 f->state = ngx_http_fastcgi_st_version;
  2285.                 f->pos += f->padding;

  2287.                 continue;
  2288.             }

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

  2293.                 break;
  2294.             }

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

  2298.             break;
  2299.         }


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

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

  2306.             if (f->length) {

  2308.                 if (f->pos == f->last) {
  2309.                     break;
  2310.                 }

  2312.                 msg = f->pos;

  2314.                 if (f->pos + f->length <= f->last) {
  2315.                     f->pos += f->length;
  2316.                     f->length = 0;
  2317.                     f->state = ngx_http_fastcgi_st_padding;

  2319.                 } else {
  2320.                     f->length -= f->last - f->pos;
  2321.                     f->pos = f->last;
  2322.                 }

  2324.                 for (m = f->pos - 1; msg < m; m--) {
  2325.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2326.                         break;
  2327.                     }
  2328.                 }

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

  2334.             } else {
  2335.                 f->state = ngx_http_fastcgi_st_padding;
  2336.             }

  2338.             continue;
  2339.         }

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

  2343.             if (f->pos + f->length <= f->last) {
  2344.                 f->state = ngx_http_fastcgi_st_padding;
  2345.                 f->pos += f->length;

  2347.                 continue;
  2348.             }

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

  2352.             break;
  2353.         }


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

  2358.         if (f->pos == f->last) {
  2359.             break;
  2360.         }

  2362.         if (f->rest == -2) {
  2363.             f->rest = r->upstream->headers_in.content_length_n;
  2364.         }

  2366.         if (f->rest == 0) {
  2367.             ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2368.                           "upstream sent more data than specified in "
  2369.                           "\"Content-Length\" header");
  2370.             p->upstream_done = 1;
  2371.             break;
  2372.         }

  2374.         cl = ngx_chain_get_free_buf(p->pool, &p->free);
  2375.         if (cl == NULL) {
  2376.             return NGX_ERROR;
  2377.         }

  2379.         b = cl->buf;

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

  2383.         b->pos = f->pos;
  2384.         b->start = buf->start;
  2385.         b->end = buf->end;
  2386.         b->tag = p->tag;
  2387.         b->temporary = 1;
  2388.         b->recycled = 1;

  2390.         *prev = b;
  2391.         prev = &b->shadow;

  2393.         if (p->in) {
  2394.             *p->last_in = cl;
  2395.         } else {
  2396.             p->in = cl;
  2397.         }
  2398.         p->last_in = &cl->next;


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

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

  2406.         if (f->pos + f->length <= f->last) {
  2407.             f->state = ngx_http_fastcgi_st_padding;
  2408.             f->pos += f->length;
  2409.             b->last = f->pos;

  2411.         } else {
  2412.             f->length -= f->last - f->pos;
  2413.             f->pos = f->last;
  2414.             b->last = f->last;
  2415.         }

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

  2419.             if (b->last - b->pos > f->rest) {
  2420.                 ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2421.                               "upstream sent more data than specified in "
  2422.                               "\"Content-Length\" header");

  2424.                 b->last = b->pos + f->rest;
  2425.                 p->upstream_done = 1;

  2427.                 break;
  2428.             }

  2430.             f->rest -= b->last - b->pos;
  2431.         }
  2432.     }

  2434.     if (flcf->keep_conn) {

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

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

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

  2444.         } else {
  2445.             /* ngx_http_fastcgi_st_data */

  2447.             p->length = f->length;
  2448.         }
  2449.     }

  2451.     if (b) {
  2452.         b->shadow = buf;
  2453.         b->last_shadow = 1;

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

  2458.         return NGX_OK;
  2459.     }

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

  2463.     if (ngx_event_pipe_add_free_buf(p, buf) != NGX_OK) {
  2464.         return NGX_ERROR;
  2465.     }

  2467.     return NGX_OK;
  2468. }


  2471. static ngx_int_t
  2472. ‌ngx_http_fastcgi_non_buffered_filter(void *data, ssize_t bytes)
  2473. {
  2474.     u_char                  *m, *msg;
  2475.     ngx_int_t                rc;
  2476.     ngx_buf_t               *b, *buf;
  2477.     ngx_chain_t             *cl, **ll;
  2478.     ngx_http_request_t      *r;
  2479.     ngx_http_upstream_t     *u;
  2480.     ngx_http_fastcgi_ctx_t  *f;

  2482.     r = data;
  2483.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  2485.     u = r->upstream;
  2486.     buf = &u->buffer;

  2488.     buf->pos = buf->last;
  2489.     buf->last += bytes;

  2491.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2492.         ll = &cl->next;
  2493.     }

  2495.     f->pos = buf->pos;
  2496.     f->last = buf->last;

  2498.     for ( ;; ) {
  2499.         if (f->state < ngx_http_fastcgi_st_data) {

  2501.             rc = ngx_http_fastcgi_process_record(r, f);

  2503.             if (rc == NGX_AGAIN) {
  2504.                 break;
  2505.             }

  2507.             if (rc == NGX_ERROR) {
  2508.                 return NGX_ERROR;
  2509.             }

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

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

  2517.                 continue;
  2518.             }
  2519.         }

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

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

  2525.                 if (f->rest > 0) {
  2526.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2527.                                   "upstream prematurely closed "
  2528.                                   "FastCGI request");
  2529.                     u->error = 1;
  2530.                     break;
  2531.                 }

  2533.                 if (f->pos + f->padding < f->last) {
  2534.                     u->length = 0;
  2535.                     break;
  2536.                 }

  2538.                 if (f->pos + f->padding == f->last) {
  2539.                     u->length = 0;
  2540.                     u->keepalive = 1;
  2541.                     break;
  2542.                 }

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

  2546.                 break;
  2547.             }

  2549.             if (f->pos + f->padding < f->last) {
  2550.                 f->state = ngx_http_fastcgi_st_version;
  2551.                 f->pos += f->padding;

  2553.                 continue;
  2554.             }

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

  2559.                 break;
  2560.             }

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

  2564.             break;
  2565.         }


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

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

  2572.             if (f->length) {

  2574.                 if (f->pos == f->last) {
  2575.                     break;
  2576.                 }

  2578.                 msg = f->pos;

  2580.                 if (f->pos + f->length <= f->last) {
  2581.                     f->pos += f->length;
  2582.                     f->length = 0;
  2583.                     f->state = ngx_http_fastcgi_st_padding;

  2585.                 } else {
  2586.                     f->length -= f->last - f->pos;
  2587.                     f->pos = f->last;
  2588.                 }

  2590.                 for (m = f->pos - 1; msg < m; m--) {
  2591.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2592.                         break;
  2593.                     }
  2594.                 }

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

  2600.             } else {
  2601.                 f->state = ngx_http_fastcgi_st_padding;
  2602.             }

  2604.             continue;
  2605.         }

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

  2609.             if (f->pos + f->length <= f->last) {
  2610.                 f->state = ngx_http_fastcgi_st_padding;
  2611.                 f->pos += f->length;

  2613.                 continue;
  2614.             }

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

  2618.             break;
  2619.         }


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

  2624.         if (f->pos == f->last) {
  2625.             break;
  2626.         }

  2628.         if (f->rest == 0) {
  2629.             ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  2630.                           "upstream sent more data than specified in "
  2631.                           "\"Content-Length\" header");
  2632.             u->length = 0;
  2633.             break;
  2634.         }

  2636.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2637.         if (cl == NULL) {
  2638.             return NGX_ERROR;
  2639.         }

  2641.         *ll = cl;
  2642.         ll = &cl->next;

  2644.         b = cl->buf;

  2646.         b->flush = 1;
  2647.         b->memory = 1;

  2649.         b->pos = f->pos;
  2650.         b->tag = u->output.tag;

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

  2655.         if (f->pos + f->length <= f->last) {
  2656.             f->state = ngx_http_fastcgi_st_padding;
  2657.             f->pos += f->length;
  2658.             b->last = f->pos;

  2660.         } else {
  2661.             f->length -= f->last - f->pos;
  2662.             f->pos = f->last;
  2663.             b->last = f->last;
  2664.         }

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

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

  2673.                 b->last = b->pos + f->rest;
  2674.                 u->length = 0;

  2676.                 break;
  2677.             }

  2679.             f->rest -= b->last - b->pos;
  2680.         }
  2681.     }

  2683.     return NGX_OK;
  2684. }


  2687. static ngx_int_t
  2688. ‌ngx_http_fastcgi_process_record(ngx_http_request_t *r,
  2689.     ngx_http_fastcgi_ctx_t *f)
  2690. {
  2691.     u_char                     ch, *p;
  2692.     ngx_http_fastcgi_state_e   state;

  2694.     state = f->state;

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

  2698.         ch = *p;

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

  2703.         switch (state) {

  2705.         case ngx_http_fastcgi_st_version:
  2706.             if (ch != 1) {
  2707.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2708.                               "upstream sent unsupported FastCGI "
  2709.                               "protocol version: %d", ch);
  2710.                 return NGX_ERROR;
  2711.             }
  2712.             state = ngx_http_fastcgi_st_type;
  2713.             break;

  2715.         case ngx_http_fastcgi_st_type:
  2716.             switch (ch) {
  2717.             case NGX_HTTP_FASTCGI_STDOUT:
  2718.             case NGX_HTTP_FASTCGI_STDERR:
  2719.             case NGX_HTTP_FASTCGI_END_REQUEST:
  2720.                 f->type = (ngx_uint_t) ch;
  2721.                 break;
  2722.             default:
  2723.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2724.                               "upstream sent invalid FastCGI "
  2725.                               "record type: %d", ch);
  2726.                 return NGX_ERROR;

  2728.             }
  2729.             state = ngx_http_fastcgi_st_request_id_hi;
  2730.             break;

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

  2734.         case ngx_http_fastcgi_st_request_id_hi:
  2735.             if (ch != 0) {
  2736.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2737.                               "upstream sent unexpected FastCGI "
  2738.                               "request id high byte: %d", ch);
  2739.                 return NGX_ERROR;
  2740.             }
  2741.             state = ngx_http_fastcgi_st_request_id_lo;
  2742.             break;

  2744.         case ngx_http_fastcgi_st_request_id_lo:
  2745.             if (ch != 1) {
  2746.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2747.                               "upstream sent unexpected FastCGI "
  2748.                               "request id low byte: %d", ch);
  2749.                 return NGX_ERROR;
  2750.             }
  2751.             state = ngx_http_fastcgi_st_content_length_hi;
  2752.             break;

  2754.         case ngx_http_fastcgi_st_content_length_hi:
  2755.             f->length = ch << 8;
  2756.             state = ngx_http_fastcgi_st_content_length_lo;
  2757.             break;

  2759.         case ngx_http_fastcgi_st_content_length_lo:
  2760.             f->length |= (size_t) ch;
  2761.             state = ngx_http_fastcgi_st_padding_length;
  2762.             break;

  2764.         case ngx_http_fastcgi_st_padding_length:
  2765.             f->padding = (size_t) ch;
  2766.             state = ngx_http_fastcgi_st_reserved;
  2767.             break;

  2769.         case ngx_http_fastcgi_st_reserved:
  2770.             state = ngx_http_fastcgi_st_data;

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

  2775.             f->pos = p + 1;
  2776.             f->state = state;

  2778.             return NGX_OK;

  2780.         /* suppress warning */
  2781.         case ngx_http_fastcgi_st_data:
  2782.         case ngx_http_fastcgi_st_padding:
  2783.             break;
  2784.         }
  2785.     }

  2787.     f->pos = p;
  2788.     f->state = state;

  2790.     return NGX_AGAIN;
  2791. }


  2794. static void
  2795. ‌ngx_http_fastcgi_abort_request(ngx_http_request_t *r)
  2796. {
  2797.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2798.                    "abort http fastcgi request");

  2800.     return;
  2801. }


  2804. static void
  2805. ‌ngx_http_fastcgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2806. {
  2807.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2808.                    "finalize http fastcgi request");

  2810.     return;
  2811. }


  2814. static ngx_int_t
  2815. ‌ngx_http_fastcgi_add_variables(ngx_conf_t *cf)
  2816. {
  2817.     ngx_http_variable_t  *var, *v;

  2819.     for (v = ngx_http_fastcgi_vars; v->name.len; v++) {
  2820.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  2821.         if (var == NULL) {
  2822.             return NGX_ERROR;
  2823.         }

  2825.         var->get_handler = v->get_handler;
  2826.         var->data = v->data;
  2827.     }

  2829.     return NGX_OK;
  2830. }


  2833. static void *
  2834. ‌ngx_http_fastcgi_create_main_conf(ngx_conf_t *cf)
  2835. {
  2836.     ngx_http_fastcgi_main_conf_t  *conf;

  2838.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_main_conf_t));
  2839.     if (conf == NULL) {
  2840.         return NULL;
  2841.     }

  2843. #if (NGX_HTTP_CACHE)
  2844.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  2845.                        sizeof(ngx_http_file_cache_t *))
  2846.         != NGX_OK)
  2847.     {
  2848.         return NULL;
  2849.     }
  2850. #endif

  2852.     return conf;
  2853. }


  2856. static void *
  2857. ‌ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf)
  2858. {
  2859.     ngx_http_fastcgi_loc_conf_t  *conf;

  2861.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_loc_conf_t));
  2862.     if (conf == NULL) {
  2863.         return NULL;
  2864.     }

  2866.     /*
  2867.      * set by ngx_pcalloc():
  2868.      *
  2869.      *     conf->upstream.bufs.num = 0;
  2870.      *     conf->upstream.ignore_headers = 0;
  2871.      *     conf->upstream.next_upstream = 0;
  2872.      *     conf->upstream.cache_zone = NULL;
  2873.      *     conf->upstream.cache_use_stale = 0;
  2874.      *     conf->upstream.cache_methods = 0;
  2875.      *     conf->upstream.temp_path = NULL;
  2876.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  2877.      *     conf->upstream.store_lengths = NULL;
  2878.      *     conf->upstream.store_values = NULL;
  2879.      *
  2880.      *     conf->index = { 0, NULL };
  2881.      */

  2883.     conf->upstream.store = NGX_CONF_UNSET;
  2884.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  2885.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  2886.     conf->upstream.buffering = NGX_CONF_UNSET;
  2887.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  2888.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  2889.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  2891.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  2892.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;

  2894.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  2895.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  2896.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  2897.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  2899.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  2900.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  2901.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  2903.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  2904.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  2905.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  2907.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  2908.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  2910. #if (NGX_HTTP_CACHE)
  2911.     conf->upstream.cache = NGX_CONF_UNSET;
  2912.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  2913.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  2914.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  2915.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  2916.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  2917.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  2918.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  2919.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  2920.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  2921.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  2922. #endif

  2924.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  2925.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  2927.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  2929.     /* "fastcgi_cyclic_temp_file" is disabled */
  2930.     conf->upstream.cyclic_temp_file = 0;

  2932.     conf->upstream.change_buffering = 1;

  2934.     conf->catch_stderr = NGX_CONF_UNSET_PTR;

  2936.     conf->keep_conn = NGX_CONF_UNSET;

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

  2940.     return conf;
  2941. }


  2944. static char *
  2945. ‌ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  2946. {
  2947.     ngx_http_fastcgi_loc_conf_t *prev = parent;
  2948.     ngx_http_fastcgi_loc_conf_t *conf = child;

  2950.     size_t                        size;
  2951.     ngx_int_t                     rc;
  2952.     ngx_hash_init_t               hash;
  2953.     ngx_http_core_loc_conf_t     *clcf;

  2955. #if (NGX_HTTP_CACHE)

  2957.     if (conf->upstream.store > 0) {
  2958.         conf->upstream.cache = 0;
  2959.     }

  2961.     if (conf->upstream.cache > 0) {
  2962.         conf->upstream.store = 0;
  2963.     }

  2965. #endif

  2967.     if (conf->upstream.store == NGX_CONF_UNSET) {
  2968.         ngx_conf_merge_value(conf->upstream.store,
  2969.                               prev->upstream.store, 0);

  2971.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  2972.         conf->upstream.store_values = prev->upstream.store_values;
  2973.     }

  2975.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  2976.                               prev->upstream.store_access, 0600);

  2978.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  2979.                               prev->upstream.next_upstream_tries, 0);

  2981.     ngx_conf_merge_value(conf->upstream.buffering,
  2982.                               prev->upstream.buffering, 1);

  2984.     ngx_conf_merge_value(conf->upstream.request_buffering,
  2985.                               prev->upstream.request_buffering, 1);

  2987.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  2988.                               prev->upstream.ignore_client_abort, 0);

  2990.     ngx_conf_merge_value(conf->upstream.force_ranges,
  2991.                               prev->upstream.force_ranges, 0);

  2993.     ngx_conf_merge_ptr_value(conf->upstream.local,
  2994.                               prev->upstream.local, NULL);

  2996.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  2997.                               prev->upstream.socket_keepalive, 0);

  2999.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  3000.                               prev->upstream.connect_timeout, 60000);

  3002.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  3003.                               prev->upstream.send_timeout, 60000);

  3005.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  3006.                               prev->upstream.read_timeout, 60000);

  3008.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  3009.                               prev->upstream.next_upstream_timeout, 0);

  3011.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  3012.                               prev->upstream.send_lowat, 0);

  3014.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  3015.                               prev->upstream.buffer_size,
  3016.                               (size_t) ngx_pagesize);

  3018.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  3019.                               prev->upstream.limit_rate, NULL);


  3022.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  3023.                               8, ngx_pagesize);

  3025.     if (conf->upstream.bufs.num < 2) {
  3026.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3027.                            "there must be at least 2 \"fastcgi_buffers\"");
  3028.         return NGX_CONF_ERROR;
  3029.     }


  3032.     size = conf->upstream.buffer_size;
  3033.     if (size < conf->upstream.bufs.size) {
  3034.         size = conf->upstream.bufs.size;
  3035.     }


  3038.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  3039.                               prev->upstream.busy_buffers_size_conf,
  3040.                               NGX_CONF_UNSET_SIZE);

  3042.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  3043.         conf->upstream.busy_buffers_size = 2 * size;
  3044.     } else {
  3045.         conf->upstream.busy_buffers_size =
  3046.                                          conf->upstream.busy_buffers_size_conf;
  3047.     }

  3049.     if (conf->upstream.busy_buffers_size < size) {
  3050.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3051.              "\"fastcgi_busy_buffers_size\" must be equal to or greater than "
  3052.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3053.              "one of the \"fastcgi_buffers\"");

  3055.         return NGX_CONF_ERROR;
  3056.     }

  3058.     if (conf->upstream.busy_buffers_size
  3059.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  3060.     {
  3061.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3062.              "\"fastcgi_busy_buffers_size\" must be less than "
  3063.              "the size of all \"fastcgi_buffers\" minus one buffer");

  3065.         return NGX_CONF_ERROR;
  3066.     }


  3069.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  3070.                               prev->upstream.temp_file_write_size_conf,
  3071.                               NGX_CONF_UNSET_SIZE);

  3073.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  3074.         conf->upstream.temp_file_write_size = 2 * size;
  3075.     } else {
  3076.         conf->upstream.temp_file_write_size =
  3077.                                       conf->upstream.temp_file_write_size_conf;
  3078.     }

  3080.     if (conf->upstream.temp_file_write_size < size) {
  3081.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3082.              "\"fastcgi_temp_file_write_size\" must be equal to or greater "
  3083.              "than the maximum of the value of \"fastcgi_buffer_size\" and "
  3084.              "one of the \"fastcgi_buffers\"");

  3086.         return NGX_CONF_ERROR;
  3087.     }


  3090.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  3091.                               prev->upstream.max_temp_file_size_conf,
  3092.                               NGX_CONF_UNSET_SIZE);

  3094.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  3095.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  3096.     } else {
  3097.         conf->upstream.max_temp_file_size =
  3098.                                         conf->upstream.max_temp_file_size_conf;
  3099.     }

  3101.     if (conf->upstream.max_temp_file_size != 0
  3102.         && conf->upstream.max_temp_file_size < size)
  3103.     {
  3104.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3105.              "\"fastcgi_max_temp_file_size\" must be equal to zero to disable "
  3106.              "temporary files usage or must be equal to or greater than "
  3107.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3108.              "one of the \"fastcgi_buffers\"");

  3110.         return NGX_CONF_ERROR;
  3111.     }


  3114.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  3115.                               prev->upstream.ignore_headers,
  3116.                               NGX_CONF_BITMASK_SET);


  3119.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  3120.                               prev->upstream.next_upstream,
  3121.                               (NGX_CONF_BITMASK_SET
  3122.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  3123.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  3125.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  3126.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  3127.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  3128.     }

  3130.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  3131.                               prev->upstream.temp_path,
  3132.                               &ngx_http_fastcgi_temp_path)
  3133.         != NGX_OK)
  3134.     {
  3135.         return NGX_CONF_ERROR;
  3136.     }

  3138. #if (NGX_HTTP_CACHE)

  3140.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  3141.         ngx_conf_merge_value(conf->upstream.cache,
  3142.                               prev->upstream.cache, 0);

  3144.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  3145.         conf->upstream.cache_value = prev->upstream.cache_value;
  3146.     }

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

  3151.         shm_zone = conf->upstream.cache_zone;

  3153.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3154.                            "\"fastcgi_cache\" zone \"%V\" is unknown",
  3155.                            &shm_zone->shm.name);

  3157.         return NGX_CONF_ERROR;
  3158.     }

  3160.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  3161.                               prev->upstream.cache_min_uses, 1);

  3163.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  3164.                               prev->upstream.cache_max_range_offset,
  3165.                               NGX_MAX_OFF_T_VALUE);

  3167.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  3168.                               prev->upstream.cache_use_stale,
  3169.                               (NGX_CONF_BITMASK_SET
  3170.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  3172.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  3173.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  3174.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  3175.     }

  3177.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  3178.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  3179.     }

  3181.     if (conf->upstream.cache_methods == 0) {
  3182.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  3183.     }

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

  3187.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  3188.                              prev->upstream.cache_bypass, NULL);

  3190.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  3191.                              prev->upstream.no_cache, NULL);

  3193.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  3194.                              prev->upstream.cache_valid, NULL);

  3196.     if (conf->cache_key.value.data == NULL) {
  3197.         conf->cache_key = prev->cache_key;
  3198.     }

  3200.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  3201.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3202.                            "no \"fastcgi_cache_key\" for \"fastcgi_cache\"");
  3203.     }

  3205.     ngx_conf_merge_value(conf->upstream.cache_lock,
  3206.                               prev->upstream.cache_lock, 0);

  3208.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  3209.                               prev->upstream.cache_lock_timeout, 5000);

  3211.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  3212.                               prev->upstream.cache_lock_age, 5000);

  3214.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  3215.                               prev->upstream.cache_revalidate, 0);

  3217.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  3218.                               prev->upstream.cache_background_update, 0);

  3220. #endif

  3222.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  3223.                               prev->upstream.pass_request_headers, 1);
  3224.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  3225.                               prev->upstream.pass_request_body, 1);

  3227.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  3228.                               prev->upstream.intercept_errors, 0);

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

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


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

  3237.     hash.max_size = 512;
  3238.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  3239.     hash.name = "fastcgi_hide_headers_hash";

  3241.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  3242.              &prev->upstream, ngx_http_fastcgi_hide_headers, &hash)
  3243.         != NGX_OK)
  3244.     {
  3245.         return NGX_CONF_ERROR;
  3246.     }

  3248.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3250.     if (clcf->noname
  3251.         && conf->upstream.upstream == NULL && conf->fastcgi_lengths == NULL)
  3252.     {
  3253.         conf->upstream.upstream = prev->upstream.upstream;
  3254.         conf->fastcgi_lengths = prev->fastcgi_lengths;
  3255.         conf->fastcgi_values = prev->fastcgi_values;
  3256.     }

  3258.     if (clcf->lmt_excpt && clcf->handler == NULL
  3259.         && (conf->upstream.upstream || conf->fastcgi_lengths))
  3260.     {
  3261.         clcf->handler = ngx_http_fastcgi_handler;
  3262.     }

  3264. #if (NGX_PCRE)
  3265.     if (conf->split_regex == NULL) {
  3266.         conf->split_regex = prev->split_regex;
  3267.         conf->split_name = prev->split_name;
  3268.     }
  3269. #endif

  3271.     if (conf->params_source == NULL) {
  3272.         conf->params = prev->params;
  3273. #if (NGX_HTTP_CACHE)
  3274.         conf->params_cache = prev->params_cache;
  3275. #endif
  3276.         conf->params_source = prev->params_source;
  3277.     }

  3279.     rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params, NULL);
  3280.     if (rc != NGX_OK) {
  3281.         return NGX_CONF_ERROR;
  3282.     }

  3284. #if (NGX_HTTP_CACHE)

  3286.     if (conf->upstream.cache) {
  3287.         rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params_cache,
  3288.                                           ngx_http_fastcgi_cache_headers);
  3289.         if (rc != NGX_OK) {
  3290.             return NGX_CONF_ERROR;
  3291.         }
  3292.     }

  3294. #endif

  3296.     /*
  3297.      * special handling to preserve conf->params in the "http" section
  3298.      * to inherit it to all servers
  3299.      */

  3301.     if (prev->params.hash.buckets == NULL
  3302.         && conf->params_source == prev->params_source)
  3303.     {
  3304.         prev->params = conf->params;
  3305. #if (NGX_HTTP_CACHE)
  3306.         prev->params_cache = conf->params_cache;
  3307. #endif
  3308.     }

  3310.     return NGX_CONF_OK;
  3311. }


  3314. static ngx_int_t
  3315. ‌ngx_http_fastcgi_init_params(ngx_conf_t *cf, ngx_http_fastcgi_loc_conf_t *conf,
  3316.     ngx_http_fastcgi_params_t *params, ngx_keyval_t *default_params)
  3317. {
  3318.     u_char                       *p;
  3319.     size_t                        size;
  3320.     uintptr_t                    *code;
  3321.     ngx_uint_t                    i, nsrc;
  3322.     ngx_array_t                   headers_names, params_merged;
  3323.     ngx_keyval_t                 *h;
  3324.     ngx_hash_key_t               *hk;
  3325.     ngx_hash_init_t               hash;
  3326.     ngx_http_upstream_param_t    *src, *s;
  3327.     ngx_http_script_compile_t     sc;
  3328.     ngx_http_script_copy_code_t  *copy;

  3330.     if (params->hash.buckets) {
  3331.         return NGX_OK;
  3332.     }

  3334.     if (conf->params_source == NULL && default_params == NULL) {
  3335.         params->hash.buckets = (void *) 1;
  3336.         return NGX_OK;
  3337.     }

  3339.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  3340.     if (params->lengths == NULL) {
  3341.         return NGX_ERROR;
  3342.     }

  3344.     params->values = ngx_array_create(cf->pool, 512, 1);
  3345.     if (params->values == NULL) {
  3346.         return NGX_ERROR;
  3347.     }

  3349.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  3350.         != NGX_OK)
  3351.     {
  3352.         return NGX_ERROR;
  3353.     }

  3355.     if (conf->params_source) {
  3356.         src = conf->params_source->elts;
  3357.         nsrc = conf->params_source->nelts;

  3359.     } else {
  3360.         src = NULL;
  3361.         nsrc = 0;
  3362.     }

  3364.     if (default_params) {
  3365.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  3366.                            sizeof(ngx_http_upstream_param_t))
  3367.             != NGX_OK)
  3368.         {
  3369.             return NGX_ERROR;
  3370.         }

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

  3374.             s = ngx_array_push(&params_merged);
  3375.             if (s == NULL) {
  3376.                 return NGX_ERROR;
  3377.             }

  3379.             *s = src[i];
  3380.         }

  3382.         h = default_params;

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

  3386.             src = params_merged.elts;
  3387.             nsrc = params_merged.nelts;

  3389.             for (i = 0; i < nsrc; i++) {
  3390.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  3391.                     goto next;
  3392.                 }
  3393.             }

  3395.             s = ngx_array_push(&params_merged);
  3396.             if (s == NULL) {
  3397.                 return NGX_ERROR;
  3398.             }

  3400.             s->key = h->key;
  3401.             s->value = h->value;
  3402.             s->skip_empty = 1;

  3404.         next:

  3406.             h++;
  3407.         }

  3409.         src = params_merged.elts;
  3410.         nsrc = params_merged.nelts;
  3411.     }

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

  3415.         if (src[i].key.len > sizeof("HTTP_") - 1
  3416.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  3417.         {
  3418.             hk = ngx_array_push(&headers_names);
  3419.             if (hk == NULL) {
  3420.                 return NGX_ERROR;
  3421.             }

  3423.             hk->key.len = src[i].key.len - 5;
  3424.             hk->key.data = src[i].key.data + 5;
  3425.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  3426.             hk->value = (void *) 1;

  3428.             if (src[i].value.len == 0) {
  3429.                 continue;
  3430.             }
  3431.         }

  3433.         copy = ngx_array_push_n(params->lengths,
  3434.                                 sizeof(ngx_http_script_copy_code_t));
  3435.         if (copy == NULL) {
  3436.             return NGX_ERROR;
  3437.         }

  3439.         copy->code = (ngx_http_script_code_pt) (void *)
  3440.                                                  ngx_http_script_copy_len_code;
  3441.         copy->len = src[i].key.len;

  3443.         copy = ngx_array_push_n(params->lengths,
  3444.                                 sizeof(ngx_http_script_copy_code_t));
  3445.         if (copy == NULL) {
  3446.             return NGX_ERROR;
  3447.         }

  3449.         copy->code = (ngx_http_script_code_pt) (void *)
  3450.                                                  ngx_http_script_copy_len_code;
  3451.         copy->len = src[i].skip_empty;


  3454.         size = (sizeof(ngx_http_script_copy_code_t)
  3455.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  3456.                & ~(sizeof(uintptr_t) - 1);

  3458.         copy = ngx_array_push_n(params->values, size);
  3459.         if (copy == NULL) {
  3460.             return NGX_ERROR;
  3461.         }

  3463.         copy->code = ngx_http_script_copy_code;
  3464.         copy->len = src[i].key.len;

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


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

  3472.         sc.cf = cf;
  3473.         sc.source = &src[i].value;
  3474.         sc.flushes = &params->flushes;
  3475.         sc.lengths = &params->lengths;
  3476.         sc.values = &params->values;

  3478.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3479.             return NGX_ERROR;
  3480.         }

  3482.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3483.         if (code == NULL) {
  3484.             return NGX_ERROR;
  3485.         }

  3487.         *code = (uintptr_t) NULL;


  3490.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  3491.         if (code == NULL) {
  3492.             return NGX_ERROR;
  3493.         }

  3495.         *code = (uintptr_t) NULL;
  3496.     }

  3498.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3499.     if (code == NULL) {
  3500.         return NGX_ERROR;
  3501.     }

  3503.     *code = (uintptr_t) NULL;

  3505.     params->number = headers_names.nelts;

  3507.     hash.hash = &params->hash;
  3508.     hash.key = ngx_hash_key_lc;
  3509.     hash.max_size = 512;
  3510.     hash.bucket_size = 64;
  3511.     hash.name = "fastcgi_params_hash";
  3512.     hash.pool = cf->pool;
  3513.     hash.temp_pool = NULL;

  3515.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  3516. }


  3519. static ngx_int_t
  3520. ‌ngx_http_fastcgi_script_name_variable(ngx_http_request_t *r,
  3521.     ngx_http_variable_value_t *v, uintptr_t data)
  3522. {
  3523.     u_char                       *p;
  3524.     ngx_http_fastcgi_ctx_t       *f;
  3525.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3527.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3529.     f = ngx_http_fastcgi_split(r, flcf);

  3531.     if (f == NULL) {
  3532.         return NGX_ERROR;
  3533.     }

  3535.     if (f->script_name.len == 0
  3536.         || f->script_name.data[f->script_name.len - 1] != '/')
  3537.     {
  3538.         v->len = f->script_name.len;
  3539.         v->valid = 1;
  3540.         v->no_cacheable = 0;
  3541.         v->not_found = 0;
  3542.         v->data = f->script_name.data;

  3544.         return NGX_OK;
  3545.     }

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

  3549.     v->data = ngx_pnalloc(r->pool, v->len);
  3550.     if (v->data == NULL) {
  3551.         return NGX_ERROR;
  3552.     }

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

  3557.     return NGX_OK;
  3558. }


  3561. static ngx_int_t
  3562. ‌ngx_http_fastcgi_path_info_variable(ngx_http_request_t *r,
  3563.     ngx_http_variable_value_t *v, uintptr_t data)
  3564. {
  3565.     ngx_http_fastcgi_ctx_t       *f;
  3566.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3568.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3570.     f = ngx_http_fastcgi_split(r, flcf);

  3572.     if (f == NULL) {
  3573.         return NGX_ERROR;
  3574.     }

  3576.     v->len = f->path_info.len;
  3577.     v->valid = 1;
  3578.     v->no_cacheable = 0;
  3579.     v->not_found = 0;
  3580.     v->data = f->path_info.data;

  3582.     return NGX_OK;
  3583. }


  3586. static ngx_http_fastcgi_ctx_t *
  3587. ‌ngx_http_fastcgi_split(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  3588. {
  3589.     ngx_http_fastcgi_ctx_t       *f;
  3590. #if (NGX_PCRE)
  3591.     ngx_int_t                     n;
  3592.     int                           captures[(1 + 2) * 3];

  3594.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3596.     if (f == NULL) {
  3597.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3598.         if (f == NULL) {
  3599.             return NULL;
  3600.         }

  3602.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3603.     }

  3605.     if (f->script_name.len) {
  3606.         return f;
  3607.     }

  3609.     if (flcf->split_regex == NULL) {
  3610.         f->script_name = r->uri;
  3611.         return f;
  3612.     }

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

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

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

  3623.         return f;
  3624.     }

  3626.     if (n == NGX_REGEX_NO_MATCHED) {
  3627.         f->script_name = r->uri;
  3628.         return f;
  3629.     }

  3631.     ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  3632.                   ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  3633.                   n, &r->uri, &flcf->split_name);
  3634.     return NULL;

  3636. #else

  3638.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3640.     if (f == NULL) {
  3641.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3642.         if (f == NULL) {
  3643.             return NULL;
  3644.         }

  3646.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3647.     }

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

  3651.     return f;

  3653. #endif
  3654. }


  3657. static char *
  3658. ‌ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3659. {
  3660.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3662.     ngx_url_t                   u;
  3663.     ngx_str_t                  *value, *url;
  3664.     ngx_uint_t                  n;
  3665.     ngx_http_core_loc_conf_t   *clcf;
  3666.     ngx_http_script_compile_t   sc;

  3668.     if (flcf->upstream.upstream || flcf->fastcgi_lengths) {
  3669.         return "is duplicate";
  3670.     }

  3672.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3674.     clcf->handler = ngx_http_fastcgi_handler;

  3676.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  3677.         clcf->auto_redirect = 1;
  3678.     }

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

  3682.     url = &value[1];

  3684.     n = ngx_http_script_variables_count(url);

  3686.     if (n) {

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

  3690.         sc.cf = cf;
  3691.         sc.source = url;
  3692.         sc.lengths = &flcf->fastcgi_lengths;
  3693.         sc.values = &flcf->fastcgi_values;
  3694.         sc.variables = n;
  3695.         sc.complete_lengths = 1;
  3696.         sc.complete_values = 1;

  3698.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3699.             return NGX_CONF_ERROR;
  3700.         }

  3702.         return NGX_CONF_OK;
  3703.     }

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

  3707.     u.url = value[1];
  3708.     u.no_resolve = 1;

  3710.     flcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  3711.     if (flcf->upstream.upstream == NULL) {
  3712.         return NGX_CONF_ERROR;
  3713.     }

  3715.     return NGX_CONF_OK;
  3716. }


  3719. static char *
  3720. ‌ngx_http_fastcgi_split_path_info(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3721. {
  3722. #if (NGX_PCRE)
  3723.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3725.     ngx_str_t            *value;
  3726.     ngx_regex_compile_t   rc;
  3727.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

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

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

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

  3735.     rc.pattern = value[1];
  3736.     rc.pool = cf->pool;
  3737.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3738.     rc.err.data = errstr;

  3740.     if (ngx_regex_compile(&rc) != NGX_OK) {
  3741.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  3742.         return NGX_CONF_ERROR;
  3743.     }

  3745.     if (rc.captures != 2) {
  3746.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3747.                            "pattern \"%V\" must have 2 captures", &value[1]);
  3748.         return NGX_CONF_ERROR;
  3749.     }

  3751.     flcf->split_regex = rc.regex;

  3753.     return NGX_CONF_OK;

  3755. #else

  3757.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3758.                        "\"%V\" requires PCRE library", &cmd->name);
  3759.     return NGX_CONF_ERROR;

  3761. #endif
  3762. }


  3765. static char *
  3766. ‌ngx_http_fastcgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3767. {
  3768.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3770.     ngx_str_t                  *value;
  3771.     ngx_http_script_compile_t   sc;

  3773.     if (flcf->upstream.store != NGX_CONF_UNSET) {
  3774.         return "is duplicate";
  3775.     }

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

  3779.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3780.         flcf->upstream.store = 0;
  3781.         return NGX_CONF_OK;
  3782.     }

  3784.     if (value[1].len == 0) {
  3785.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  3786.         return NGX_CONF_ERROR;
  3787.     }

  3789. #if (NGX_HTTP_CACHE)
  3790.     if (flcf->upstream.cache > 0) {
  3791.         return "is incompatible with \"fastcgi_cache\"";
  3792.     }
  3793. #endif

  3795.     flcf->upstream.store = 1;

  3797.     if (ngx_strcmp(value[1].data, "on") == 0) {
  3798.         return NGX_CONF_OK;
  3799.     }

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

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

  3806.     sc.cf = cf;
  3807.     sc.source = &value[1];
  3808.     sc.lengths = &flcf->upstream.store_lengths;
  3809.     sc.values = &flcf->upstream.store_values;
  3810.     sc.variables = ngx_http_script_variables_count(&value[1]);
  3811.     sc.complete_lengths = 1;
  3812.     sc.complete_values = 1;

  3814.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  3815.         return NGX_CONF_ERROR;
  3816.     }

  3818.     return NGX_CONF_OK;
  3819. }


  3822. #if (NGX_HTTP_CACHE)

  3824. static char *
  3825. ‌ngx_http_fastcgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3826. {
  3827.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3829.     ngx_str_t                         *value;
  3830.     ngx_http_complex_value_t           cv;
  3831.     ngx_http_compile_complex_value_t   ccv;

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

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

  3839.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3840.         flcf->upstream.cache = 0;
  3841.         return NGX_CONF_OK;
  3842.     }

  3844.     if (flcf->upstream.store > 0) {
  3845.         return "is incompatible with \"fastcgi_store\"";
  3846.     }

  3848.     flcf->upstream.cache = 1;

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

  3852.     ccv.cf = cf;
  3853.     ccv.value = &value[1];
  3854.     ccv.complex_value = &cv;

  3856.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3857.         return NGX_CONF_ERROR;
  3858.     }

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

  3862.         flcf->upstream.cache_value = ngx_palloc(cf->pool,
  3863.                                              sizeof(ngx_http_complex_value_t));
  3864.         if (flcf->upstream.cache_value == NULL) {
  3865.             return NGX_CONF_ERROR;
  3866.         }

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

  3870.         return NGX_CONF_OK;
  3871.     }

  3873.     flcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  3874.                                                       &ngx_http_fastcgi_module);
  3875.     if (flcf->upstream.cache_zone == NULL) {
  3876.         return NGX_CONF_ERROR;
  3877.     }

  3879.     return NGX_CONF_OK;
  3880. }


  3883. static char *
  3884. ‌ngx_http_fastcgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3885. {
  3886.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3888.     ngx_str_t                         *value;
  3889.     ngx_http_compile_complex_value_t   ccv;

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

  3893.     if (flcf->cache_key.value.data) {
  3894.         return "is duplicate";
  3895.     }

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

  3899.     ccv.cf = cf;
  3900.     ccv.value = &value[1];
  3901.     ccv.complex_value = &flcf->cache_key;

  3903.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3904.         return NGX_CONF_ERROR;
  3905.     }

  3907.     return NGX_CONF_OK;
  3908. }

  3910. #endif


  3913. static char *
  3914. ‌ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post, void *data)
  3915. {
  3916. #if (NGX_FREEBSD)
  3917.     ssize_t *np = data;

  3919.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  3920.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3921.                            "\"fastcgi_send_lowat\" must be less than %d "
  3922.                            "(sysctl net.inet.tcp.sendspace)",
  3923.                            ngx_freebsd_net_inet_tcp_sendspace);

  3925.         return NGX_CONF_ERROR;
  3926.     }

  3928. #elif !(NGX_HAVE_SO_SNDLOWAT)
  3929.     ssize_t *np = data;

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

  3934.     *np = 0;

  3936. #endif

  3938.     return NGX_CONF_OK;
  3939. }

One Level Up Top Level