One Level Up Top Level

src/http/modules/ngx_http_fastcgi_module.c - nginx

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. ‌static ngx_keyval_t  ngx_http_fastcgi_headers[] = {
  660.     { ngx_string("HTTP_HOST"),
  661.       ngx_string("$host$is_request_port$request_port") },
  662.     { ngx_null_string, ngx_null_string }
  663. };


  666. #if (NGX_HTTP_CACHE)

  668. ‌static ngx_keyval_t  ngx_http_fastcgi_cache_headers[] = {
  669.     { ngx_string("HTTP_HOST"),
  670.       ngx_string("$host$is_request_port$request_port") },
  671.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  672.       ngx_string("$upstream_cache_last_modified") },
  673.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  674.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  675.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  676.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  677.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  678.     { ngx_null_string, ngx_null_string }
  679. };

  681. #endif


  684. ‌static ngx_path_init_t  ngx_http_fastcgi_temp_path = {
  685.     ngx_string(NGX_HTTP_FASTCGI_TEMP_PATH), { 1, 2, 0 }
  686. };


  689. static ngx_int_t
  690. ‌ngx_http_fastcgi_handler(ngx_http_request_t *r)
  691. {
  692.     ngx_int_t                      rc;
  693.     ngx_http_upstream_t           *u;
  694.     ngx_http_fastcgi_ctx_t        *f;
  695.     ngx_http_fastcgi_loc_conf_t   *flcf;
  696. #if (NGX_HTTP_CACHE)
  697.     ngx_http_fastcgi_main_conf_t  *fmcf;
  698. #endif

  700.     if (ngx_http_upstream_create(r) != NGX_OK) {
  701.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  702.     }

  704.     f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  705.     if (f == NULL) {
  706.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  707.     }

  709.     ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);

  711.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  713.     if (flcf->fastcgi_lengths) {
  714.         if (ngx_http_fastcgi_eval(r, flcf) != NGX_OK) {
  715.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  716.         }
  717.     }

  719.     u = r->upstream;

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

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

  726. #if (NGX_HTTP_CACHE)
  727.     fmcf = ngx_http_get_module_main_conf(r, ngx_http_fastcgi_module);

  729.     u->caches = &fmcf->caches;
  730.     u->create_key = ngx_http_fastcgi_create_key;
  731. #endif

  733.     u->create_request = ngx_http_fastcgi_create_request;
  734.     u->reinit_request = ngx_http_fastcgi_reinit_request;
  735.     u->process_header = ngx_http_fastcgi_process_header;
  736.     u->abort_request = ngx_http_fastcgi_abort_request;
  737.     u->finalize_request = ngx_http_fastcgi_finalize_request;
  738.     r->state = 0;

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

  742.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  743.     if (u->pipe == NULL) {
  744.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  745.     }

  747.     u->pipe->input_filter = ngx_http_fastcgi_input_filter;
  748.     u->pipe->input_ctx = r;

  750.     u->input_filter_init = ngx_http_fastcgi_input_filter_init;
  751.     u->input_filter = ngx_http_fastcgi_non_buffered_filter;
  752.     u->input_filter_ctx = r;

  754.     if (!flcf->upstream.request_buffering
  755.         && flcf->upstream.pass_request_body)
  756.     {
  757.         r->request_body_no_buffering = 1;
  758.     }

  760.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  762.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  763.         return rc;
  764.     }

  766.     return NGX_DONE;
  767. }


  770. static ngx_int_t
  771. ‌ngx_http_fastcgi_eval(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  772. {
  773.     ngx_url_t             url;
  774.     ngx_http_upstream_t  *u;

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

  778.     if (ngx_http_script_run(r, &url.url, flcf->fastcgi_lengths->elts, 0,
  779.                             flcf->fastcgi_values->elts)
  780.         == NULL)
  781.     {
  782.         return NGX_ERROR;
  783.     }

  785.     url.no_resolve = 1;

  787.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  788.         if (url.err) {
  789.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  790.                           "%s in upstream \"%V\"", url.err, &url.url);
  791.         }

  793.         return NGX_ERROR;
  794.     }

  796.     u = r->upstream;

  798.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  799.     if (u->resolved == NULL) {
  800.         return NGX_ERROR;
  801.     }

  803.     if (url.addrs) {
  804.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  805.         u->resolved->socklen = url.addrs[0].socklen;
  806.         u->resolved->name = url.addrs[0].name;
  807.         u->resolved->naddrs = 1;
  808.     }

  810.     u->resolved->host = url.host;
  811.     u->resolved->port = url.port;
  812.     u->resolved->no_port = url.no_port;

  814.     return NGX_OK;
  815. }


  818. #if (NGX_HTTP_CACHE)

  820. static ngx_int_t
  821. ‌ngx_http_fastcgi_create_key(ngx_http_request_t *r)
  822. {
  823.     ngx_str_t                    *key;
  824.     ngx_http_fastcgi_loc_conf_t  *flcf;

  826.     key = ngx_array_push(&r->cache->keys);
  827.     if (key == NULL) {
  828.         return NGX_ERROR;
  829.     }

  831.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  833.     if (ngx_http_complex_value(r, &flcf->cache_key, key) != NGX_OK) {
  834.         return NGX_ERROR;
  835.     }

  837.     return NGX_OK;
  838. }

  840. #endif


  843. static ngx_int_t
  844. ‌ngx_http_fastcgi_create_request(ngx_http_request_t *r)
  845. {
  846.     off_t                         file_pos;
  847.     u_char                        ch, sep, *pos, *lowcase_key;
  848.     size_t                        size, len, key_len, val_len, padding,
  849.                                   allocated;
  850.     ngx_uint_t                    i, n, next, hash, skip_empty, header_params;
  851.     ngx_buf_t                    *b;
  852.     ngx_chain_t                  *cl, *body;
  853.     ngx_list_part_t              *part;
  854.     ngx_table_elt_t              *header, *hn, **ignored;
  855.     ngx_http_upstream_t          *u;
  856.     ngx_http_script_code_pt       code;
  857.     ngx_http_script_engine_t      e, le;
  858.     ngx_http_fastcgi_header_t    *h;
  859.     ngx_http_fastcgi_params_t    *params;
  860.     ngx_http_fastcgi_loc_conf_t  *flcf;
  861.     ngx_http_script_len_code_pt   lcode;

  863.     len = 0;
  864.     header_params = 0;
  865.     ignored = NULL;

  867.     u = r->upstream;

  869.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  871. #if (NGX_HTTP_CACHE)
  872.     params = u->cacheable ? &flcf->params_cache : &flcf->params;
  873. #else
  874.     params = &flcf->params;
  875. #endif

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

  880.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  881.         le.flushed = 1;

  883.         le.ip = params->lengths->elts;
  884.         le.request = r;

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

  888.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  889.             key_len = lcode(&le);

  891.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  892.             skip_empty = lcode(&le);

  894.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  895.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  896.             }
  897.             le.ip += sizeof(uintptr_t);

  899.             if (skip_empty && val_len == 0) {
  900.                 continue;
  901.             }

  903.             len += 1 + key_len + ((val_len > 127) ? 4 : 1) + val_len;
  904.         }
  905.     }

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

  909.         allocated = 0;
  910.         lowcase_key = NULL;

  912.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  913.             return NGX_ERROR;
  914.         }

  916.         if (params->number || r->headers_in.multi) {
  917.             n = 0;
  918.             part = &r->headers_in.headers.part;

  920.             while (part) {
  921.                 n += part->nelts;
  922.                 part = part->next;
  923.             }

  925.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  926.             if (ignored == NULL) {
  927.                 return NGX_ERROR;
  928.             }
  929.         }

  931.         part = &r->headers_in.headers.part;
  932.         header = part->elts;

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

  936.             if (i >= part->nelts) {
  937.                 if (part->next == NULL) {
  938.                     break;
  939.                 }

  941.                 part = part->next;
  942.                 header = part->elts;
  943.                 i = 0;
  944.             }

  946.             for (n = 0; n < header_params; n++) {
  947.                 if (&header[i] == ignored[n]) {
  948.                     goto next_length;
  949.                 }
  950.             }

  952.             if (params->number) {
  953.                 if (allocated < header[i].key.len) {
  954.                     allocated = header[i].key.len + 16;
  955.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  956.                     if (lowcase_key == NULL) {
  957.                         return NGX_ERROR;
  958.                     }
  959.                 }

  961.                 hash = 0;

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

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

  969.                     } else if (ch == '-') {
  970.                         ch = '_';
  971.                     }

  973.                     hash = ngx_hash(hash, ch);
  974.                     lowcase_key[n] = ch;
  975.                 }

  977.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  978.                     ignored[header_params++] = &header[i];
  979.                     continue;
  980.                 }
  981.             }

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

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

  987.             for (hn = header[i].next; hn; hn = hn->next) {
  988.                 val_len += hn->value.len + 2;
  989.                 ignored[header_params++] = hn;
  990.             }

  992.             len += ((key_len > 127) ? 4 : 1) + key_len
  993.                    + ((val_len > 127) ? 4 : 1) + val_len;

  995.         next_length:

  997.             continue;
  998.         }
  999.     }


  1002.     if (len > 65535) {
  1003.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1004.                       "fastcgi request record is too big: %uz", len);
  1005.         return NGX_ERROR;
  1006.     }


  1009.     padding = 8 - len % 8;
  1010.     padding = (padding == 8) ? 0 : padding;


  1013.     size = sizeof(ngx_http_fastcgi_header_t)
  1014.            + sizeof(ngx_http_fastcgi_begin_request_t)

  1016.            + sizeof(ngx_http_fastcgi_header_t)  /* NGX_HTTP_FASTCGI_PARAMS */
  1017.            + len + padding
  1018.            + sizeof(ngx_http_fastcgi_header_t)  /* NGX_HTTP_FASTCGI_PARAMS */

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


  1023.     b = ngx_create_temp_buf(r->pool, size);
  1024.     if (b == NULL) {
  1025.         return NGX_ERROR;
  1026.     }

  1028.     cl = ngx_alloc_chain_link(r->pool);
  1029.     if (cl == NULL) {
  1030.         return NGX_ERROR;
  1031.     }

  1033.     cl->buf = b;

  1035.     ngx_http_fastcgi_request_start.br.flags =
  1036.         flcf->keep_conn ? NGX_HTTP_FASTCGI_KEEP_CONN : 0;

  1038.     ngx_memcpy(b->pos, &ngx_http_fastcgi_request_start,
  1039.                sizeof(ngx_http_fastcgi_request_start_t));

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

  1045.     h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1046.     h->content_length_lo = (u_char) (len & 0xff);
  1047.     h->padding_length = (u_char) padding;
  1048.     h->reserved = 0;

  1050.     b->last = b->pos + sizeof(ngx_http_fastcgi_header_t)
  1051.                      + sizeof(ngx_http_fastcgi_begin_request_t)
  1052.                      + sizeof(ngx_http_fastcgi_header_t);


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

  1058.         e.ip = params->values->elts;
  1059.         e.pos = b->last;
  1060.         e.request = r;
  1061.         e.flushed = 1;

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

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

  1067.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1068.             key_len = (u_char) lcode(&le);

  1070.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1071.             skip_empty = lcode(&le);

  1073.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1074.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1075.             }
  1076.             le.ip += sizeof(uintptr_t);

  1078.             if (skip_empty && val_len == 0) {
  1079.                 e.skip = 1;

  1081.                 while (*(uintptr_t *) e.ip) {
  1082.                     code = *(ngx_http_script_code_pt *) e.ip;
  1083.                     code((ngx_http_script_engine_t *) &e);
  1084.                 }
  1085.                 e.ip += sizeof(uintptr_t);

  1087.                 e.skip = 0;

  1089.                 continue;
  1090.             }

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

  1094.             if (val_len > 127) {
  1095.                 *e.pos++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1096.                 *e.pos++ = (u_char) ((val_len >> 16) & 0xff);
  1097.                 *e.pos++ = (u_char) ((val_len >> 8) & 0xff);
  1098.                 *e.pos++ = (u_char) (val_len & 0xff);

  1100.             } else {
  1101.                 *e.pos++ = (u_char) val_len;
  1102.             }

  1104.             while (*(uintptr_t *) e.ip) {
  1105.                 code = *(ngx_http_script_code_pt *) e.ip;
  1106.                 code((ngx_http_script_engine_t *) &e);
  1107.             }
  1108.             e.ip += sizeof(uintptr_t);

  1110.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1111.                            "fastcgi param: \"%*s: %*s\"",
  1112.                            key_len, e.pos - (key_len + val_len),
  1113.                            val_len, e.pos - val_len);
  1114.         }

  1116.         b->last = e.pos;
  1117.     }


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

  1122.         part = &r->headers_in.headers.part;
  1123.         header = part->elts;

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

  1127.             if (i >= part->nelts) {
  1128.                 if (part->next == NULL) {
  1129.                     break;
  1130.                 }

  1132.                 part = part->next;
  1133.                 header = part->elts;
  1134.                 i = 0;
  1135.             }

  1137.             for (n = 0; n < header_params; n++) {
  1138.                 if (&header[i] == ignored[n]) {
  1139.                     goto next_value;
  1140.                 }
  1141.             }

  1143.             key_len = sizeof("HTTP_") - 1 + header[i].key.len;
  1144.             if (key_len > 127) {
  1145.                 *b->last++ = (u_char) (((key_len >> 24) & 0x7f) | 0x80);
  1146.                 *b->last++ = (u_char) ((key_len >> 16) & 0xff);
  1147.                 *b->last++ = (u_char) ((key_len >> 8) & 0xff);
  1148.                 *b->last++ = (u_char) (key_len & 0xff);

  1150.             } else {
  1151.                 *b->last++ = (u_char) key_len;
  1152.             }

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

  1156.             for (hn = header[i].next; hn; hn = hn->next) {
  1157.                 val_len += hn->value.len + 2;
  1158.             }

  1160.             if (val_len > 127) {
  1161.                 *b->last++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1162.                 *b->last++ = (u_char) ((val_len >> 16) & 0xff);
  1163.                 *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1164.                 *b->last++ = (u_char) (val_len & 0xff);

  1166.             } else {
  1167.                 *b->last++ = (u_char) val_len;
  1168.             }

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

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

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

  1178.                 } else if (ch == '-') {
  1179.                     ch = '_';
  1180.                 }

  1182.                 *b->last++ = ch;
  1183.             }

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

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

  1190.                 if (header[i].key.len == sizeof("Cookie") - 1
  1191.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1192.                                        sizeof("Cookie") - 1)
  1193.                        == 0)
  1194.                 {
  1195.                     sep = ';';

  1197.                 } else {
  1198.                     sep = ',';
  1199.                 }

  1201.                 for (hn = header[i].next; hn; hn = hn->next) {
  1202.                     *b->last++ = sep;
  1203.                     *b->last++ = ' ';
  1204.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1205.                 }
  1206.             }

  1208.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1209.                            "fastcgi param: \"%*s: %*s\"",
  1210.                            key_len, b->last - (key_len + val_len),
  1211.                            val_len, b->last - val_len);
  1212.         next_value:

  1214.             continue;
  1215.         }
  1216.     }


  1219.     if (padding) {
  1220.         ngx_memzero(b->last, padding);
  1221.         b->last += padding;
  1222.     }


  1225.     h = (ngx_http_fastcgi_header_t *) b->last;
  1226.     b->last += sizeof(ngx_http_fastcgi_header_t);

  1228.     h->version = 1;
  1229.     h->type = NGX_HTTP_FASTCGI_PARAMS;
  1230.     h->request_id_hi = 0;
  1231.     h->request_id_lo = 1;
  1232.     h->content_length_hi = 0;
  1233.     h->content_length_lo = 0;
  1234.     h->padding_length = 0;
  1235.     h->reserved = 0;

  1237.     if (r->request_body_no_buffering) {

  1239.         u->request_bufs = cl;

  1241.         u->output.output_filter = ngx_http_fastcgi_body_output_filter;
  1242.         u->output.filter_ctx = r;

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

  1246.         body = u->request_bufs;
  1247.         u->request_bufs = cl;

  1249. #if (NGX_SUPPRESS_WARN)
  1250.         file_pos = 0;
  1251.         pos = NULL;
  1252. #endif

  1254.         while (body) {

  1256.             if (ngx_buf_special(body->buf)) {
  1257.                 body = body->next;
  1258.                 continue;
  1259.             }

  1261.             if (body->buf->in_file) {
  1262.                 file_pos = body->buf->file_pos;

  1264.             } else {
  1265.                 pos = body->buf->pos;
  1266.             }

  1268.             next = 0;

  1270.             do {
  1271.                 b = ngx_alloc_buf(r->pool);
  1272.                 if (b == NULL) {
  1273.                     return NGX_ERROR;
  1274.                 }

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

  1278.                 if (body->buf->in_file) {
  1279.                     b->file_pos = file_pos;
  1280.                     file_pos += 32 * 1024;

  1282.                     if (file_pos >= body->buf->file_last) {
  1283.                         file_pos = body->buf->file_last;
  1284.                         next = 1;
  1285.                     }

  1287.                     b->file_last = file_pos;
  1288.                     len = (ngx_uint_t) (file_pos - b->file_pos);

  1290.                 } else {
  1291.                     b->pos = pos;
  1292.                     b->start = pos;
  1293.                     pos += 32 * 1024;

  1295.                     if (pos >= body->buf->last) {
  1296.                         pos = body->buf->last;
  1297.                         next = 1;
  1298.                     }

  1300.                     b->last = pos;
  1301.                     len = (ngx_uint_t) (pos - b->pos);
  1302.                 }

  1304.                 padding = 8 - len % 8;
  1305.                 padding = (padding == 8) ? 0 : padding;

  1307.                 h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1308.                 cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1310.                 h->version = 1;
  1311.                 h->type = NGX_HTTP_FASTCGI_STDIN;
  1312.                 h->request_id_hi = 0;
  1313.                 h->request_id_lo = 1;
  1314.                 h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1315.                 h->content_length_lo = (u_char) (len & 0xff);
  1316.                 h->padding_length = (u_char) padding;
  1317.                 h->reserved = 0;

  1319.                 cl->next = ngx_alloc_chain_link(r->pool);
  1320.                 if (cl->next == NULL) {
  1321.                     return NGX_ERROR;
  1322.                 }

  1324.                 cl = cl->next;
  1325.                 cl->buf = b;

  1327.                 b = ngx_create_temp_buf(r->pool,
  1328.                                         sizeof(ngx_http_fastcgi_header_t)
  1329.                                         + padding);
  1330.                 if (b == NULL) {
  1331.                     return NGX_ERROR;
  1332.                 }

  1334.                 if (padding) {
  1335.                     ngx_memzero(b->last, padding);
  1336.                     b->last += padding;
  1337.                 }

  1339.                 cl->next = ngx_alloc_chain_link(r->pool);
  1340.                 if (cl->next == NULL) {
  1341.                     return NGX_ERROR;
  1342.                 }

  1344.                 cl = cl->next;
  1345.                 cl->buf = b;

  1347.             } while (!next);

  1349.             body = body->next;
  1350.         }

  1352.     } else {
  1353.         u->request_bufs = cl;
  1354.     }

  1356.     if (!r->request_body_no_buffering) {
  1357.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1358.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1360.         h->version = 1;
  1361.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1362.         h->request_id_hi = 0;
  1363.         h->request_id_lo = 1;
  1364.         h->content_length_hi = 0;
  1365.         h->content_length_lo = 0;
  1366.         h->padding_length = 0;
  1367.         h->reserved = 0;
  1368.     }

  1370.     cl->next = NULL;

  1372.     return NGX_OK;
  1373. }


  1376. static ngx_int_t
  1377. ‌ngx_http_fastcgi_reinit_request(ngx_http_request_t *r)
  1378. {
  1379.     ngx_http_fastcgi_ctx_t  *f;

  1381.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1383.     if (f == NULL) {
  1384.         return NGX_OK;
  1385.     }

  1387.     f->state = ngx_http_fastcgi_st_version;
  1388.     f->fastcgi_stdout = 0;
  1389.     f->large_stderr = 0;

  1391.     if (f->split_parts) {
  1392.         f->split_parts->nelts = 0;
  1393.     }

  1395.     r->state = 0;

  1397.     return NGX_OK;
  1398. }


  1401. static ngx_int_t
  1402. ‌ngx_http_fastcgi_body_output_filter(void *data, ngx_chain_t *in)
  1403. {
  1404.     ngx_http_request_t  *r = data;

  1406.     off_t                       file_pos;
  1407.     u_char                     *pos, *start;
  1408.     size_t                      len, padding;
  1409.     ngx_buf_t                  *b;
  1410.     ngx_int_t                   rc;
  1411.     ngx_uint_t                  next, last;
  1412.     ngx_chain_t                *cl, *tl, *out, **ll;
  1413.     ngx_http_fastcgi_ctx_t     *f;
  1414.     ngx_http_fastcgi_header_t  *h;

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

  1419.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1421.     if (in == NULL) {
  1422.         out = in;
  1423.         goto out;
  1424.     }

  1426.     out = NULL;
  1427.     ll = &out;

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

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

  1435.         f->header_sent = 1;

  1437.         tl = ngx_alloc_chain_link(r->pool);
  1438.         if (tl == NULL) {
  1439.             return NGX_ERROR;
  1440.         }

  1442.         tl->buf = in->buf;
  1443.         *ll = tl;
  1444.         ll = &tl->next;

  1446.         in = in->next;

  1448.         if (in == NULL) {
  1449.             tl->next = NULL;
  1450.             goto out;
  1451.         }
  1452.     }

  1454.     cl = ngx_chain_get_free_buf(r->pool, &f->free);
  1455.     if (cl == NULL) {
  1456.         return NGX_ERROR;
  1457.     }

  1459.     b = cl->buf;

  1461.     b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1462.     b->temporary = 1;

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

  1467.         b->start = ngx_palloc(r->pool,
  1468.                               sizeof(ngx_http_fastcgi_header_t) + 7);
  1469.         if (b->start == NULL) {
  1470.             return NGX_ERROR;
  1471.         }

  1473.         b->pos = b->start;
  1474.         b->last = b->start;

  1476.         b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1477.     }

  1479.     *ll = cl;

  1481.     last = 0;
  1482.     padding = 0;

  1484. #if (NGX_SUPPRESS_WARN)
  1485.     file_pos = 0;
  1486.     pos = NULL;
  1487. #endif

  1489.     while (in) {

  1491.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1492.                        "fastcgi output in  l:%d f:%d %p, pos %p, size: %z "
  1493.                        "file: %O, size: %O",
  1494.                        in->buf->last_buf,
  1495.                        in->buf->in_file,
  1496.                        in->buf->start, in->buf->pos,
  1497.                        in->buf->last - in->buf->pos,
  1498.                        in->buf->file_pos,
  1499.                        in->buf->file_last - in->buf->file_pos);

  1501.         if (in->buf->last_buf) {
  1502.             last = 1;
  1503.         }

  1505.         if (ngx_buf_special(in->buf)) {
  1506.             in = in->next;
  1507.             continue;
  1508.         }

  1510.         if (in->buf->in_file) {
  1511.             file_pos = in->buf->file_pos;

  1513.         } else {
  1514.             pos = in->buf->pos;
  1515.         }

  1517.         next = 0;

  1519.         do {
  1520.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1521.             if (tl == NULL) {
  1522.                 return NGX_ERROR;
  1523.             }

  1525.             b = tl->buf;
  1526.             start = b->start;

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

  1530.             /*
  1531.              * restore b->start to preserve memory allocated in the buffer,
  1532.              * to reuse it later for headers and padding
  1533.              */

  1535.             b->start = start;

  1537.             if (in->buf->in_file) {
  1538.                 b->file_pos = file_pos;
  1539.                 file_pos += 32 * 1024;

  1541.                 if (file_pos >= in->buf->file_last) {
  1542.                     file_pos = in->buf->file_last;
  1543.                     next = 1;
  1544.                 }

  1546.                 b->file_last = file_pos;
  1547.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1549.             } else {
  1550.                 b->pos = pos;
  1551.                 pos += 32 * 1024;

  1553.                 if (pos >= in->buf->last) {
  1554.                     pos = in->buf->last;
  1555.                     next = 1;
  1556.                 }

  1558.                 b->last = pos;
  1559.                 len = (ngx_uint_t) (pos - b->pos);
  1560.             }

  1562.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1563.             b->shadow = in->buf;
  1564.             b->last_shadow = next;

  1566.             b->last_buf = 0;
  1567.             b->last_in_chain = 0;

  1569.             padding = 8 - len % 8;
  1570.             padding = (padding == 8) ? 0 : padding;

  1572.             h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1573.             cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1575.             h->version = 1;
  1576.             h->type = NGX_HTTP_FASTCGI_STDIN;
  1577.             h->request_id_hi = 0;
  1578.             h->request_id_lo = 1;
  1579.             h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1580.             h->content_length_lo = (u_char) (len & 0xff);
  1581.             h->padding_length = (u_char) padding;
  1582.             h->reserved = 0;

  1584.             cl->next = tl;
  1585.             cl = tl;

  1587.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1588.             if (tl == NULL) {
  1589.                 return NGX_ERROR;
  1590.             }

  1592.             b = tl->buf;

  1594.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1595.             b->temporary = 1;

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

  1600.                 b->start = ngx_palloc(r->pool,
  1601.                                       sizeof(ngx_http_fastcgi_header_t) + 7);
  1602.                 if (b->start == NULL) {
  1603.                     return NGX_ERROR;
  1604.                 }

  1606.                 b->pos = b->start;
  1607.                 b->last = b->start;

  1609.                 b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1610.             }

  1612.             if (padding) {
  1613.                 ngx_memzero(b->last, padding);
  1614.                 b->last += padding;
  1615.             }

  1617.             cl->next = tl;
  1618.             cl = tl;

  1620.         } while (!next);

  1622.         in = in->next;
  1623.     }

  1625.     if (last) {
  1626.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1627.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1629.         h->version = 1;
  1630.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1631.         h->request_id_hi = 0;
  1632.         h->request_id_lo = 1;
  1633.         h->content_length_hi = 0;
  1634.         h->content_length_lo = 0;
  1635.         h->padding_length = 0;
  1636.         h->reserved = 0;

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

  1640.     } else if (padding == 0) {
  1641.         /* TODO: do not allocate buffers instead */
  1642.         cl->buf->temporary = 0;
  1643.         cl->buf->sync = 1;
  1644.     }

  1646.     cl->next = NULL;

  1648. out:

  1650. #if (NGX_DEBUG)

  1652.     for (cl = out; cl; cl = cl->next) {
  1653.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1654.                        "fastcgi output out l:%d f:%d %p, pos %p, size: %z "
  1655.                        "file: %O, size: %O",
  1656.                        cl->buf->last_buf,
  1657.                        cl->buf->in_file,
  1658.                        cl->buf->start, cl->buf->pos,
  1659.                        cl->buf->last - cl->buf->pos,
  1660.                        cl->buf->file_pos,
  1661.                        cl->buf->file_last - cl->buf->file_pos);
  1662.     }

  1664. #endif

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

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

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

  1673.         /* mark original buffers as sent */

  1675.         if (cl->buf->shadow) {
  1676.             if (cl->buf->last_shadow) {
  1677.                 b = cl->buf->shadow;
  1678.                 b->pos = b->last;
  1679.             }

  1681.             cl->buf->shadow = NULL;
  1682.         }
  1683.     }

  1685.     return rc;
  1686. }


  1689. static ngx_int_t
  1690. ‌ngx_http_fastcgi_process_header(ngx_http_request_t *r)
  1691. {
  1692.     u_char                         *p, *msg, *start, *last,
  1693.                                    *part_start, *part_end;
  1694.     size_t                          size;
  1695.     ngx_str_t                      *status_line, *pattern;
  1696.     ngx_int_t                       rc, status;
  1697.     ngx_buf_t                       buf;
  1698.     ngx_uint_t                      i;
  1699.     ngx_table_elt_t                *h;
  1700.     ngx_http_upstream_t            *u;
  1701.     ngx_http_fastcgi_ctx_t         *f;
  1702.     ngx_http_upstream_header_t     *hh;
  1703.     ngx_http_fastcgi_loc_conf_t    *flcf;
  1704.     ngx_http_fastcgi_split_part_t  *part;
  1705.     ngx_http_upstream_main_conf_t  *umcf;

  1707.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1709.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1711.     u = r->upstream;

  1713.     for ( ;; ) {

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

  1717.             f->pos = u->buffer.pos;
  1718.             f->last = u->buffer.last;

  1720.             rc = ngx_http_fastcgi_process_record(r, f);

  1722.             u->buffer.pos = f->pos;
  1723.             u->buffer.last = f->last;

  1725.             if (rc == NGX_AGAIN) {
  1726.                 return NGX_AGAIN;
  1727.             }

  1729.             if (rc == NGX_ERROR) {
  1730.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1731.             }

  1733.             if (f->type != NGX_HTTP_FASTCGI_STDOUT
  1734.                 && f->type != NGX_HTTP_FASTCGI_STDERR)
  1735.             {
  1736.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1737.                               "upstream sent unexpected FastCGI record: %ui",
  1738.                               f->type);

  1740.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1741.             }

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

  1747.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1748.             }
  1749.         }

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

  1753.             if (u->buffer.pos + f->padding < u->buffer.last) {
  1754.                 f->state = ngx_http_fastcgi_st_version;
  1755.                 u->buffer.pos += f->padding;

  1757.                 continue;
  1758.             }

  1760.             if (u->buffer.pos + f->padding == u->buffer.last) {
  1761.                 f->state = ngx_http_fastcgi_st_version;
  1762.                 u->buffer.pos = u->buffer.last;

  1764.                 return NGX_AGAIN;
  1765.             }

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

  1770.             return NGX_AGAIN;
  1771.         }


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

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

  1778.             if (f->length) {
  1779.                 msg = u->buffer.pos;

  1781.                 if (u->buffer.pos + f->length <= u->buffer.last) {
  1782.                     u->buffer.pos += f->length;
  1783.                     f->length = 0;
  1784.                     f->state = ngx_http_fastcgi_st_padding;

  1786.                 } else {
  1787.                     f->length -= u->buffer.last - u->buffer.pos;
  1788.                     u->buffer.pos = u->buffer.last;
  1789.                 }

  1791.                 for (p = u->buffer.pos - 1; msg < p; p--) {
  1792.                     if (*p != LF && *p != CR && *p != '.' && *p != ' ') {
  1793.                         break;
  1794.                     }
  1795.                 }

  1797.                 p++;

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

  1802.                 flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  1804.                 if (flcf->catch_stderr) {
  1805.                     pattern = flcf->catch_stderr->elts;

  1807.                     for (i = 0; i < flcf->catch_stderr->nelts; i++) {
  1808.                         if (ngx_strnstr(msg, (char *) pattern[i].data,
  1809.                                         p - msg)
  1810.                             != NULL)
  1811.                         {
  1812.                             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1813.                         }
  1814.                     }
  1815.                 }

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

  1819.                     if (!f->fastcgi_stdout) {

  1821.                         /*
  1822.                          * the special handling the large number
  1823.                          * of the PHP warnings to not allocate memory
  1824.                          */

  1826. #if (NGX_HTTP_CACHE)
  1827.                         if (r->cache) {
  1828.                             u->buffer.pos = u->buffer.start
  1829.                                                      + r->cache->header_start;
  1830.                         } else {
  1831.                             u->buffer.pos = u->buffer.start;
  1832.                         }
  1833. #else
  1834.                         u->buffer.pos = u->buffer.start;
  1835. #endif
  1836.                         u->buffer.last = u->buffer.pos;
  1837.                         f->large_stderr = 1;
  1838.                     }

  1840.                     return NGX_AGAIN;
  1841.                 }

  1843.             } else {
  1844.                 f->state = ngx_http_fastcgi_st_padding;
  1845.             }

  1847.             continue;
  1848.         }


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

  1853. #if (NGX_HTTP_CACHE)

  1855.         if (f->large_stderr && r->cache) {
  1856.             ssize_t                     len;
  1857.             ngx_http_fastcgi_header_t  *fh;

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

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

  1863.             /*
  1864.              * A tail of large stderr output before HTTP header is placed
  1865.              * in a cache file without a FastCGI record header.
  1866.              * To workaround it we put a dummy FastCGI record header at the
  1867.              * start of the stderr output or update r->cache_header_start,
  1868.              * if there is no enough place for the record header.
  1869.              */

  1871.             if (len >= 0) {
  1872.                 fh = (ngx_http_fastcgi_header_t *) start;
  1873.                 fh->version = 1;
  1874.                 fh->type = NGX_HTTP_FASTCGI_STDERR;
  1875.                 fh->request_id_hi = 0;
  1876.                 fh->request_id_lo = 1;
  1877.                 fh->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1878.                 fh->content_length_lo = (u_char) (len & 0xff);
  1879.                 fh->padding_length = 0;
  1880.                 fh->reserved = 0;

  1882.             } else {
  1883.                 r->cache->header_start += u->buffer.pos - start
  1884.                                           - sizeof(ngx_http_fastcgi_header_t);
  1885.             }

  1887.             f->large_stderr = 0;
  1888.         }

  1890. #endif

  1892.         f->fastcgi_stdout = 1;

  1894.         start = u->buffer.pos;

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

  1898.             /*
  1899.              * set u->buffer.last to the end of the FastCGI record data
  1900.              * for ngx_http_parse_header_line()
  1901.              */

  1903.             last = u->buffer.last;
  1904.             u->buffer.last = u->buffer.pos + f->length;

  1906.         } else {
  1907.             last = NULL;
  1908.         }

  1910.         for ( ;; ) {

  1912.             part_start = u->buffer.pos;
  1913.             part_end = u->buffer.last;

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

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

  1920.             if (rc == NGX_AGAIN) {
  1921.                 break;
  1922.             }

  1924.             if (rc == NGX_OK) {

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

  1928.                 h = ngx_list_push(&u->headers_in.headers);
  1929.                 if (h == NULL) {
  1930.                     return NGX_ERROR;
  1931.                 }

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

  1935.                     part = f->split_parts->elts;
  1936.                     size = u->buffer.pos - part_start;

  1938.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1939.                         size += part[i].end - part[i].start;
  1940.                     }

  1942.                     p = ngx_pnalloc(r->pool, size);
  1943.                     if (p == NULL) {
  1944.                         h->hash = 0;
  1945.                         return NGX_ERROR;
  1946.                     }

  1948.                     buf.pos = p;

  1950.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1951.                         p = ngx_cpymem(p, part[i].start,
  1952.                                        part[i].end - part[i].start);
  1953.                     }

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

  1957.                     buf.last = p;

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

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

  1963.                     if (rc != NGX_OK) {
  1964.                         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1965.                                       "invalid header after joining "
  1966.                                       "FastCGI records");
  1967.                         h->hash = 0;
  1968.                         return NGX_ERROR;
  1969.                     }

  1971.                     h->key.len = r->header_name_end - r->header_name_start;
  1972.                     h->key.data = r->header_name_start;
  1973.                     h->key.data[h->key.len] = '\0';

  1975.                     h->value.len = r->header_end - r->header_start;
  1976.                     h->value.data = r->header_start;
  1977.                     h->value.data[h->value.len] = '\0';

  1979.                     h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  1980.                     if (h->lowcase_key == NULL) {
  1981.                         return NGX_ERROR;
  1982.                     }

  1984.                 } else {

  1986.                     h->key.len = r->header_name_end - r->header_name_start;
  1987.                     h->value.len = r->header_end - r->header_start;

  1989.                     h->key.data = ngx_pnalloc(r->pool,
  1990.                                               h->key.len + 1 + h->value.len + 1
  1991.                                               + h->key.len);
  1992.                     if (h->key.data == NULL) {
  1993.                         h->hash = 0;
  1994.                         return NGX_ERROR;
  1995.                     }

  1997.                     h->value.data = h->key.data + h->key.len + 1;
  1998.                     h->lowcase_key = h->key.data + h->key.len + 1
  1999.                                      + h->value.len + 1;

  2001.                     ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  2002.                     h->key.data[h->key.len] = '\0';
  2003.                     ngx_memcpy(h->value.data, r->header_start, h->value.len);
  2004.                     h->value.data[h->value.len] = '\0';
  2005.                 }

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

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

  2012.                 } else {
  2013.                     ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  2014.                 }

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

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

  2022.                     if (rc != NGX_OK) {
  2023.                         return rc;
  2024.                     }
  2025.                 }

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

  2031.                 if (u->buffer.pos < u->buffer.last) {
  2032.                     continue;
  2033.                 }

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

  2037.                 break;
  2038.             }

  2040.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2047.                 if (u->headers_in.status) {
  2048.                     status_line = &u->headers_in.status->value;

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

  2052.                     if (status == NGX_ERROR) {
  2053.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2054.                                       "upstream sent invalid status \"%V\"",
  2055.                                       status_line);
  2056.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2057.                     }

  2059.                     u->headers_in.status_n = status;

  2061.                     if (status_line->len > 3) {
  2062.                         u->headers_in.status_line = *status_line;
  2063.                     }

  2065.                 } else if (u->headers_in.location) {
  2066.                     u->headers_in.status_n = 302;
  2067.                     ngx_str_set(&u->headers_in.status_line,
  2068.                                 "302 Moved Temporarily");

  2070.                 } else {
  2071.                     u->headers_in.status_n = 200;
  2072.                     ngx_str_set(&u->headers_in.status_line, "200 OK");
  2073.                 }

  2075.                 if (u->state && u->state->status == 0) {
  2076.                     u->state->status = u->headers_in.status_n;
  2077.                 }

  2079.                 break;
  2080.             }

  2082.             /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  2084.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2085.                           "upstream sent invalid header: \"%*s\\x%02xd...\"",
  2086.                           r->header_end - r->header_name_start,
  2087.                           r->header_name_start, *r->header_end);

  2089.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2090.         }

  2092.         if (last) {
  2093.             u->buffer.last = last;
  2094.         }

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

  2098.         if (f->length == 0) {
  2099.             f->state = ngx_http_fastcgi_st_padding;
  2100.         }

  2102.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2103.             return NGX_OK;
  2104.         }

  2106.         if (rc == NGX_OK) {
  2107.             continue;
  2108.         }

  2110.         /* rc == NGX_AGAIN */

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

  2115.         if (f->split_parts == NULL) {
  2116.             f->split_parts = ngx_array_create(r->pool, 1,
  2117.                                         sizeof(ngx_http_fastcgi_split_part_t));
  2118.             if (f->split_parts == NULL) {
  2119.                 return NGX_ERROR;
  2120.             }
  2121.         }

  2123.         part = ngx_array_push(f->split_parts);
  2124.         if (part == NULL) {
  2125.             return NGX_ERROR;
  2126.         }

  2128.         part->start = part_start;
  2129.         part->end = part_end;

  2131.         if (u->buffer.pos < u->buffer.last) {
  2132.             continue;
  2133.         }

  2135.         return NGX_AGAIN;
  2136.     }
  2137. }


  2140. static ngx_int_t
  2141. ‌ngx_http_fastcgi_input_filter_init(void *data)
  2142. {
  2143.     ngx_http_request_t  *r = data;

  2145.     ngx_http_upstream_t          *u;
  2146.     ngx_http_fastcgi_ctx_t       *f;
  2147.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2149.     u = r->upstream;

  2151.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2152.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

  2157.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  2158.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  2159.     {
  2160.         f->rest = 0;

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

  2165.     } else {
  2166.         f->rest = u->headers_in.content_length_n;
  2167.     }

  2169.     return NGX_OK;
  2170. }


  2173. static ngx_int_t
  2174. ‌ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
  2175. {
  2176.     u_char                       *m, *msg;
  2177.     ngx_int_t                     rc;
  2178.     ngx_buf_t                    *b, **prev;
  2179.     ngx_chain_t                  *cl;
  2180.     ngx_http_request_t           *r;
  2181.     ngx_http_fastcgi_ctx_t       *f;
  2182.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2184.     if (buf->pos == buf->last) {
  2185.         return NGX_OK;
  2186.     }

  2188.     r = p->input_ctx;
  2189.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2190.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

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

  2198.         return NGX_OK;
  2199.     }

  2201.     b = NULL;
  2202.     prev = &buf->shadow;

  2204.     f->pos = buf->pos;
  2205.     f->last = buf->last;

  2207.     for ( ;; ) {
  2208.         if (f->state < ngx_http_fastcgi_st_data) {

  2210.             rc = ngx_http_fastcgi_process_record(r, f);

  2212.             if (rc == NGX_AGAIN) {
  2213.                 break;
  2214.             }

  2216.             if (rc == NGX_ERROR) {
  2217.                 return NGX_ERROR;
  2218.             }

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

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

  2226.                 if (f->rest > 0) {
  2227.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2228.                                   "upstream prematurely closed "
  2229.                                   "FastCGI stdout");

  2231.                     p->upstream_error = 1;
  2232.                     p->upstream_eof = 0;
  2233.                     f->closed = 1;

  2235.                     break;
  2236.                 }

  2238.                 if (!flcf->keep_conn) {
  2239.                     p->upstream_done = 1;
  2240.                 }

  2242.                 continue;
  2243.             }

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

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

  2250.                 if (f->rest > 0) {
  2251.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2252.                                   "upstream prematurely closed "
  2253.                                   "FastCGI request");

  2255.                     p->upstream_error = 1;
  2256.                     p->upstream_eof = 0;
  2257.                     f->closed = 1;

  2259.                     break;
  2260.                 }

  2262.                 if (!flcf->keep_conn) {
  2263.                     p->upstream_done = 1;
  2264.                     break;
  2265.                 }

  2267.                 continue;
  2268.             }
  2269.         }


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

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

  2276.                 if (f->pos + f->padding < f->last) {
  2277.                     p->upstream_done = 1;
  2278.                     break;
  2279.                 }

  2281.                 if (f->pos + f->padding == f->last) {
  2282.                     p->upstream_done = 1;
  2283.                     r->upstream->keepalive = 1;
  2284.                     break;
  2285.                 }

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

  2289.                 break;
  2290.             }

  2292.             if (f->pos + f->padding < f->last) {
  2293.                 f->state = ngx_http_fastcgi_st_version;
  2294.                 f->pos += f->padding;

  2296.                 continue;
  2297.             }

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

  2302.                 break;
  2303.             }

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

  2307.             break;
  2308.         }


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

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

  2315.             if (f->length) {

  2317.                 if (f->pos == f->last) {
  2318.                     break;
  2319.                 }

  2321.                 msg = f->pos;

  2323.                 if (f->pos + f->length <= f->last) {
  2324.                     f->pos += f->length;
  2325.                     f->length = 0;
  2326.                     f->state = ngx_http_fastcgi_st_padding;

  2328.                 } else {
  2329.                     f->length -= f->last - f->pos;
  2330.                     f->pos = f->last;
  2331.                 }

  2333.                 for (m = f->pos - 1; msg < m; m--) {
  2334.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2335.                         break;
  2336.                     }
  2337.                 }

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

  2343.             } else {
  2344.                 f->state = ngx_http_fastcgi_st_padding;
  2345.             }

  2347.             continue;
  2348.         }

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

  2352.             if (f->pos + f->length <= f->last) {
  2353.                 f->state = ngx_http_fastcgi_st_padding;
  2354.                 f->pos += f->length;

  2356.                 continue;
  2357.             }

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

  2361.             break;
  2362.         }


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

  2367.         if (f->pos == f->last) {
  2368.             break;
  2369.         }

  2371.         if (f->rest == -2) {
  2372.             f->rest = r->upstream->headers_in.content_length_n;
  2373.         }

  2375.         if (f->rest == 0) {
  2376.             ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2377.                           "upstream sent more data than specified in "
  2378.                           "\"Content-Length\" header");
  2379.             p->upstream_done = 1;
  2380.             break;
  2381.         }

  2383.         cl = ngx_chain_get_free_buf(p->pool, &p->free);
  2384.         if (cl == NULL) {
  2385.             return NGX_ERROR;
  2386.         }

  2388.         b = cl->buf;

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

  2392.         b->pos = f->pos;
  2393.         b->start = buf->start;
  2394.         b->end = buf->end;
  2395.         b->tag = p->tag;
  2396.         b->temporary = 1;
  2397.         b->recycled = 1;

  2399.         *prev = b;
  2400.         prev = &b->shadow;

  2402.         if (p->in) {
  2403.             *p->last_in = cl;
  2404.         } else {
  2405.             p->in = cl;
  2406.         }
  2407.         p->last_in = &cl->next;


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

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

  2415.         if (f->pos + f->length <= f->last) {
  2416.             f->state = ngx_http_fastcgi_st_padding;
  2417.             f->pos += f->length;
  2418.             b->last = f->pos;

  2420.         } else {
  2421.             f->length -= f->last - f->pos;
  2422.             f->pos = f->last;
  2423.             b->last = f->last;
  2424.         }

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

  2428.             if (b->last - b->pos > f->rest) {
  2429.                 ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2430.                               "upstream sent more data than specified in "
  2431.                               "\"Content-Length\" header");

  2433.                 b->last = b->pos + f->rest;
  2434.                 p->upstream_done = 1;

  2436.                 break;
  2437.             }

  2439.             f->rest -= b->last - b->pos;
  2440.         }
  2441.     }

  2443.     if (flcf->keep_conn) {

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

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

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

  2453.         } else {
  2454.             /* ngx_http_fastcgi_st_data */

  2456.             p->length = f->length;
  2457.         }
  2458.     }

  2460.     if (b) {
  2461.         b->shadow = buf;
  2462.         b->last_shadow = 1;

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

  2467.         return NGX_OK;
  2468.     }

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

  2472.     if (ngx_event_pipe_add_free_buf(p, buf) != NGX_OK) {
  2473.         return NGX_ERROR;
  2474.     }

  2476.     return NGX_OK;
  2477. }


  2480. static ngx_int_t
  2481. ‌ngx_http_fastcgi_non_buffered_filter(void *data, ssize_t bytes)
  2482. {
  2483.     u_char                  *m, *msg;
  2484.     ngx_int_t                rc;
  2485.     ngx_buf_t               *b, *buf;
  2486.     ngx_chain_t             *cl, **ll;
  2487.     ngx_http_request_t      *r;
  2488.     ngx_http_upstream_t     *u;
  2489.     ngx_http_fastcgi_ctx_t  *f;

  2491.     r = data;
  2492.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  2494.     u = r->upstream;
  2495.     buf = &u->buffer;

  2497.     buf->pos = buf->last;
  2498.     buf->last += bytes;

  2500.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2501.         ll = &cl->next;
  2502.     }

  2504.     f->pos = buf->pos;
  2505.     f->last = buf->last;

  2507.     for ( ;; ) {
  2508.         if (f->state < ngx_http_fastcgi_st_data) {

  2510.             rc = ngx_http_fastcgi_process_record(r, f);

  2512.             if (rc == NGX_AGAIN) {
  2513.                 break;
  2514.             }

  2516.             if (rc == NGX_ERROR) {
  2517.                 return NGX_ERROR;
  2518.             }

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

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

  2526.                 continue;
  2527.             }
  2528.         }

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

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

  2534.                 if (f->rest > 0) {
  2535.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2536.                                   "upstream prematurely closed "
  2537.                                   "FastCGI request");
  2538.                     u->error = 1;
  2539.                     break;
  2540.                 }

  2542.                 if (f->pos + f->padding < f->last) {
  2543.                     u->length = 0;
  2544.                     break;
  2545.                 }

  2547.                 if (f->pos + f->padding == f->last) {
  2548.                     u->length = 0;
  2549.                     u->keepalive = 1;
  2550.                     break;
  2551.                 }

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

  2555.                 break;
  2556.             }

  2558.             if (f->pos + f->padding < f->last) {
  2559.                 f->state = ngx_http_fastcgi_st_version;
  2560.                 f->pos += f->padding;

  2562.                 continue;
  2563.             }

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

  2568.                 break;
  2569.             }

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

  2573.             break;
  2574.         }


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

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

  2581.             if (f->length) {

  2583.                 if (f->pos == f->last) {
  2584.                     break;
  2585.                 }

  2587.                 msg = f->pos;

  2589.                 if (f->pos + f->length <= f->last) {
  2590.                     f->pos += f->length;
  2591.                     f->length = 0;
  2592.                     f->state = ngx_http_fastcgi_st_padding;

  2594.                 } else {
  2595.                     f->length -= f->last - f->pos;
  2596.                     f->pos = f->last;
  2597.                 }

  2599.                 for (m = f->pos - 1; msg < m; m--) {
  2600.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2601.                         break;
  2602.                     }
  2603.                 }

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

  2609.             } else {
  2610.                 f->state = ngx_http_fastcgi_st_padding;
  2611.             }

  2613.             continue;
  2614.         }

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

  2618.             if (f->pos + f->length <= f->last) {
  2619.                 f->state = ngx_http_fastcgi_st_padding;
  2620.                 f->pos += f->length;

  2622.                 continue;
  2623.             }

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

  2627.             break;
  2628.         }


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

  2633.         if (f->pos == f->last) {
  2634.             break;
  2635.         }

  2637.         if (f->rest == 0) {
  2638.             ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  2639.                           "upstream sent more data than specified in "
  2640.                           "\"Content-Length\" header");
  2641.             u->length = 0;
  2642.             break;
  2643.         }

  2645.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2646.         if (cl == NULL) {
  2647.             return NGX_ERROR;
  2648.         }

  2650.         *ll = cl;
  2651.         ll = &cl->next;

  2653.         b = cl->buf;

  2655.         b->flush = 1;
  2656.         b->memory = 1;

  2658.         b->pos = f->pos;
  2659.         b->tag = u->output.tag;

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

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

  2669.         } else {
  2670.             f->length -= f->last - f->pos;
  2671.             f->pos = f->last;
  2672.             b->last = f->last;
  2673.         }

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

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

  2682.                 b->last = b->pos + f->rest;
  2683.                 u->length = 0;

  2685.                 break;
  2686.             }

  2688.             f->rest -= b->last - b->pos;
  2689.         }
  2690.     }

  2692.     return NGX_OK;
  2693. }


  2696. static ngx_int_t
  2697. ‌ngx_http_fastcgi_process_record(ngx_http_request_t *r,
  2698.     ngx_http_fastcgi_ctx_t *f)
  2699. {
  2700.     u_char                     ch, *p;
  2701.     ngx_http_fastcgi_state_e   state;

  2703.     state = f->state;

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

  2707.         ch = *p;

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

  2712.         switch (state) {

  2714.         case ngx_http_fastcgi_st_version:
  2715.             if (ch != 1) {
  2716.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2717.                               "upstream sent unsupported FastCGI "
  2718.                               "protocol version: %d", ch);
  2719.                 return NGX_ERROR;
  2720.             }
  2721.             state = ngx_http_fastcgi_st_type;
  2722.             break;

  2724.         case ngx_http_fastcgi_st_type:
  2725.             switch (ch) {
  2726.             case NGX_HTTP_FASTCGI_STDOUT:
  2727.             case NGX_HTTP_FASTCGI_STDERR:
  2728.             case NGX_HTTP_FASTCGI_END_REQUEST:
  2729.                 f->type = (ngx_uint_t) ch;
  2730.                 break;
  2731.             default:
  2732.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2733.                               "upstream sent invalid FastCGI "
  2734.                               "record type: %d", ch);
  2735.                 return NGX_ERROR;

  2737.             }
  2738.             state = ngx_http_fastcgi_st_request_id_hi;
  2739.             break;

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

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

  2753.         case ngx_http_fastcgi_st_request_id_lo:
  2754.             if (ch != 1) {
  2755.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2756.                               "upstream sent unexpected FastCGI "
  2757.                               "request id low byte: %d", ch);
  2758.                 return NGX_ERROR;
  2759.             }
  2760.             state = ngx_http_fastcgi_st_content_length_hi;
  2761.             break;

  2763.         case ngx_http_fastcgi_st_content_length_hi:
  2764.             f->length = ch << 8;
  2765.             state = ngx_http_fastcgi_st_content_length_lo;
  2766.             break;

  2768.         case ngx_http_fastcgi_st_content_length_lo:
  2769.             f->length |= (size_t) ch;
  2770.             state = ngx_http_fastcgi_st_padding_length;
  2771.             break;

  2773.         case ngx_http_fastcgi_st_padding_length:
  2774.             f->padding = (size_t) ch;
  2775.             state = ngx_http_fastcgi_st_reserved;
  2776.             break;

  2778.         case ngx_http_fastcgi_st_reserved:
  2779.             state = ngx_http_fastcgi_st_data;

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

  2784.             f->pos = p + 1;
  2785.             f->state = state;

  2787.             return NGX_OK;

  2789.         /* suppress warning */
  2790.         case ngx_http_fastcgi_st_data:
  2791.         case ngx_http_fastcgi_st_padding:
  2792.             break;
  2793.         }
  2794.     }

  2796.     f->pos = p;
  2797.     f->state = state;

  2799.     return NGX_AGAIN;
  2800. }


  2803. static void
  2804. ‌ngx_http_fastcgi_abort_request(ngx_http_request_t *r)
  2805. {
  2806.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2807.                    "abort http fastcgi request");

  2809.     return;
  2810. }


  2813. static void
  2814. ‌ngx_http_fastcgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2815. {
  2816.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2817.                    "finalize http fastcgi request");

  2819.     return;
  2820. }


  2823. static ngx_int_t
  2824. ‌ngx_http_fastcgi_add_variables(ngx_conf_t *cf)
  2825. {
  2826.     ngx_http_variable_t  *var, *v;

  2828.     for (v = ngx_http_fastcgi_vars; v->name.len; v++) {
  2829.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  2830.         if (var == NULL) {
  2831.             return NGX_ERROR;
  2832.         }

  2834.         var->get_handler = v->get_handler;
  2835.         var->data = v->data;
  2836.     }

  2838.     return NGX_OK;
  2839. }


  2842. static void *
  2843. ‌ngx_http_fastcgi_create_main_conf(ngx_conf_t *cf)
  2844. {
  2845.     ngx_http_fastcgi_main_conf_t  *conf;

  2847.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_main_conf_t));
  2848.     if (conf == NULL) {
  2849.         return NULL;
  2850.     }

  2852. #if (NGX_HTTP_CACHE)
  2853.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  2854.                        sizeof(ngx_http_file_cache_t *))
  2855.         != NGX_OK)
  2856.     {
  2857.         return NULL;
  2858.     }
  2859. #endif

  2861.     return conf;
  2862. }


  2865. static void *
  2866. ‌ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf)
  2867. {
  2868.     ngx_http_fastcgi_loc_conf_t  *conf;

  2870.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_loc_conf_t));
  2871.     if (conf == NULL) {
  2872.         return NULL;
  2873.     }

  2875.     /*
  2876.      * set by ngx_pcalloc():
  2877.      *
  2878.      *     conf->upstream.bufs.num = 0;
  2879.      *     conf->upstream.ignore_headers = 0;
  2880.      *     conf->upstream.next_upstream = 0;
  2881.      *     conf->upstream.cache_zone = NULL;
  2882.      *     conf->upstream.cache_use_stale = 0;
  2883.      *     conf->upstream.cache_methods = 0;
  2884.      *     conf->upstream.temp_path = NULL;
  2885.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  2886.      *     conf->upstream.store_lengths = NULL;
  2887.      *     conf->upstream.store_values = NULL;
  2888.      *
  2889.      *     conf->index = { 0, NULL };
  2890.      */

  2892.     conf->upstream.store = NGX_CONF_UNSET;
  2893.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  2894.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  2895.     conf->upstream.buffering = NGX_CONF_UNSET;
  2896.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  2897.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  2898.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  2900.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  2901.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;

  2903.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  2904.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  2905.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  2906.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  2908.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  2909.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  2910.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  2912.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  2913.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  2914.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  2916.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  2917.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  2919. #if (NGX_HTTP_CACHE)
  2920.     conf->upstream.cache = NGX_CONF_UNSET;
  2921.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  2922.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  2923.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  2924.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  2925.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  2926.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  2927.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  2928.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  2929.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  2930.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  2931. #endif

  2933.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  2934.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  2936.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  2938.     /* "fastcgi_cyclic_temp_file" is disabled */
  2939.     conf->upstream.cyclic_temp_file = 0;

  2941.     conf->upstream.change_buffering = 1;

  2943.     conf->catch_stderr = NGX_CONF_UNSET_PTR;

  2945.     conf->keep_conn = NGX_CONF_UNSET;

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

  2949.     return conf;
  2950. }


  2953. static char *
  2954. ‌ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  2955. {
  2956.     ngx_http_fastcgi_loc_conf_t *prev = parent;
  2957.     ngx_http_fastcgi_loc_conf_t *conf = child;

  2959.     size_t                        size;
  2960.     ngx_int_t                     rc;
  2961.     ngx_hash_init_t               hash;
  2962.     ngx_http_core_loc_conf_t     *clcf;

  2964. #if (NGX_HTTP_CACHE)

  2966.     if (conf->upstream.store > 0) {
  2967.         conf->upstream.cache = 0;
  2968.     }

  2970.     if (conf->upstream.cache > 0) {
  2971.         conf->upstream.store = 0;
  2972.     }

  2974. #endif

  2976.     if (conf->upstream.store == NGX_CONF_UNSET) {
  2977.         ngx_conf_merge_value(conf->upstream.store,
  2978.                               prev->upstream.store, 0);

  2980.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  2981.         conf->upstream.store_values = prev->upstream.store_values;
  2982.     }

  2984.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  2985.                               prev->upstream.store_access, 0600);

  2987.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  2988.                               prev->upstream.next_upstream_tries, 0);

  2990.     ngx_conf_merge_value(conf->upstream.buffering,
  2991.                               prev->upstream.buffering, 1);

  2993.     ngx_conf_merge_value(conf->upstream.request_buffering,
  2994.                               prev->upstream.request_buffering, 1);

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

  2999.     ngx_conf_merge_value(conf->upstream.force_ranges,
  3000.                               prev->upstream.force_ranges, 0);

  3002.     ngx_conf_merge_ptr_value(conf->upstream.local,
  3003.                               prev->upstream.local, NULL);

  3005.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  3006.                               prev->upstream.socket_keepalive, 0);

  3008.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  3009.                               prev->upstream.connect_timeout, 60000);

  3011.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  3012.                               prev->upstream.send_timeout, 60000);

  3014.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  3015.                               prev->upstream.read_timeout, 60000);

  3017.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  3018.                               prev->upstream.next_upstream_timeout, 0);

  3020.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  3021.                               prev->upstream.send_lowat, 0);

  3023.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  3024.                               prev->upstream.buffer_size,
  3025.                               (size_t) ngx_pagesize);

  3027.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  3028.                               prev->upstream.limit_rate, NULL);


  3031.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  3032.                               8, ngx_pagesize);

  3034.     if (conf->upstream.bufs.num < 2) {
  3035.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3036.                            "there must be at least 2 \"fastcgi_buffers\"");
  3037.         return NGX_CONF_ERROR;
  3038.     }


  3041.     size = conf->upstream.buffer_size;
  3042.     if (size < conf->upstream.bufs.size) {
  3043.         size = conf->upstream.bufs.size;
  3044.     }


  3047.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  3048.                               prev->upstream.busy_buffers_size_conf,
  3049.                               NGX_CONF_UNSET_SIZE);

  3051.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  3052.         conf->upstream.busy_buffers_size = 2 * size;
  3053.     } else {
  3054.         conf->upstream.busy_buffers_size =
  3055.                                          conf->upstream.busy_buffers_size_conf;
  3056.     }

  3058.     if (conf->upstream.busy_buffers_size < size) {
  3059.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3060.              "\"fastcgi_busy_buffers_size\" must be equal to or greater than "
  3061.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3062.              "one of the \"fastcgi_buffers\"");

  3064.         return NGX_CONF_ERROR;
  3065.     }

  3067.     if (conf->upstream.busy_buffers_size
  3068.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  3069.     {
  3070.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3071.              "\"fastcgi_busy_buffers_size\" must be less than "
  3072.              "the size of all \"fastcgi_buffers\" minus one buffer");

  3074.         return NGX_CONF_ERROR;
  3075.     }


  3078.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  3079.                               prev->upstream.temp_file_write_size_conf,
  3080.                               NGX_CONF_UNSET_SIZE);

  3082.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  3083.         conf->upstream.temp_file_write_size = 2 * size;
  3084.     } else {
  3085.         conf->upstream.temp_file_write_size =
  3086.                                       conf->upstream.temp_file_write_size_conf;
  3087.     }

  3089.     if (conf->upstream.temp_file_write_size < size) {
  3090.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3091.              "\"fastcgi_temp_file_write_size\" must be equal to or greater "
  3092.              "than the maximum of the value of \"fastcgi_buffer_size\" and "
  3093.              "one of the \"fastcgi_buffers\"");

  3095.         return NGX_CONF_ERROR;
  3096.     }


  3099.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  3100.                               prev->upstream.max_temp_file_size_conf,
  3101.                               NGX_CONF_UNSET_SIZE);

  3103.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  3104.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  3105.     } else {
  3106.         conf->upstream.max_temp_file_size =
  3107.                                         conf->upstream.max_temp_file_size_conf;
  3108.     }

  3110.     if (conf->upstream.max_temp_file_size != 0
  3111.         && conf->upstream.max_temp_file_size < size)
  3112.     {
  3113.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3114.              "\"fastcgi_max_temp_file_size\" must be equal to zero to disable "
  3115.              "temporary files usage or must be equal to or greater than "
  3116.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3117.              "one of the \"fastcgi_buffers\"");

  3119.         return NGX_CONF_ERROR;
  3120.     }


  3123.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  3124.                               prev->upstream.ignore_headers,
  3125.                               NGX_CONF_BITMASK_SET);


  3128.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  3129.                               prev->upstream.next_upstream,
  3130.                               (NGX_CONF_BITMASK_SET
  3131.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  3132.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  3134.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  3135.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  3136.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  3137.     }

  3139.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  3140.                               prev->upstream.temp_path,
  3141.                               &ngx_http_fastcgi_temp_path)
  3142.         != NGX_CONF_OK)
  3143.     {
  3144.         return NGX_CONF_ERROR;
  3145.     }

  3147. #if (NGX_HTTP_CACHE)

  3149.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  3150.         ngx_conf_merge_value(conf->upstream.cache,
  3151.                               prev->upstream.cache, 0);

  3153.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  3154.         conf->upstream.cache_value = prev->upstream.cache_value;
  3155.     }

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

  3160.         shm_zone = conf->upstream.cache_zone;

  3162.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3163.                            "\"fastcgi_cache\" zone \"%V\" is unknown",
  3164.                            &shm_zone->shm.name);

  3166.         return NGX_CONF_ERROR;
  3167.     }

  3169.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  3170.                               prev->upstream.cache_min_uses, 1);

  3172.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  3173.                               prev->upstream.cache_max_range_offset,
  3174.                               NGX_MAX_OFF_T_VALUE);

  3176.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  3177.                               prev->upstream.cache_use_stale,
  3178.                               (NGX_CONF_BITMASK_SET
  3179.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  3181.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  3182.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  3183.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  3184.     }

  3186.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  3187.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  3188.     }

  3190.     if (conf->upstream.cache_methods == 0) {
  3191.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  3192.     }

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

  3196.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  3197.                              prev->upstream.cache_bypass, NULL);

  3199.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  3200.                              prev->upstream.no_cache, NULL);

  3202.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  3203.                              prev->upstream.cache_valid, NULL);

  3205.     if (conf->cache_key.value.data == NULL) {
  3206.         conf->cache_key = prev->cache_key;
  3207.     }

  3209.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  3210.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3211.                            "no \"fastcgi_cache_key\" for \"fastcgi_cache\"");
  3212.     }

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

  3217.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  3218.                               prev->upstream.cache_lock_timeout, 5000);

  3220.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  3221.                               prev->upstream.cache_lock_age, 5000);

  3223.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  3224.                               prev->upstream.cache_revalidate, 0);

  3226.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  3227.                               prev->upstream.cache_background_update, 0);

  3229. #endif

  3231.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  3232.                               prev->upstream.pass_request_headers, 1);
  3233.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  3234.                               prev->upstream.pass_request_body, 1);

  3236.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  3237.                               prev->upstream.intercept_errors, 0);

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

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


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

  3246.     hash.max_size = 512;
  3247.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  3248.     hash.name = "fastcgi_hide_headers_hash";

  3250.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  3251.              &prev->upstream, ngx_http_fastcgi_hide_headers, &hash)
  3252.         != NGX_OK)
  3253.     {
  3254.         return NGX_CONF_ERROR;
  3255.     }

  3257.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3259.     if (clcf->noname
  3260.         && conf->upstream.upstream == NULL && conf->fastcgi_lengths == NULL)
  3261.     {
  3262.         conf->upstream.upstream = prev->upstream.upstream;
  3263.         conf->fastcgi_lengths = prev->fastcgi_lengths;
  3264.         conf->fastcgi_values = prev->fastcgi_values;
  3265.     }

  3267.     if (clcf->lmt_excpt && clcf->handler == NULL
  3268.         && (conf->upstream.upstream || conf->fastcgi_lengths))
  3269.     {
  3270.         clcf->handler = ngx_http_fastcgi_handler;
  3271.     }

  3273. #if (NGX_PCRE)
  3274.     if (conf->split_regex == NULL) {
  3275.         conf->split_regex = prev->split_regex;
  3276.         conf->split_name = prev->split_name;
  3277.     }
  3278. #endif

  3280.     if (conf->params_source == NULL) {
  3281.         conf->params = prev->params;
  3282. #if (NGX_HTTP_CACHE)
  3283.         conf->params_cache = prev->params_cache;
  3284. #endif
  3285.         conf->params_source = prev->params_source;
  3286.     }

  3288.     rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params,
  3289.                                       ngx_http_fastcgi_headers);
  3290.     if (rc != NGX_OK) {
  3291.         return NGX_CONF_ERROR;
  3292.     }

  3294. #if (NGX_HTTP_CACHE)

  3296.     if (conf->upstream.cache) {
  3297.         rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params_cache,
  3298.                                           ngx_http_fastcgi_cache_headers);
  3299.         if (rc != NGX_OK) {
  3300.             return NGX_CONF_ERROR;
  3301.         }
  3302.     }

  3304. #endif

  3306.     /*
  3307.      * special handling to preserve conf->params in the "http" section
  3308.      * to inherit it to all servers
  3309.      */

  3311.     if (prev->params.hash.buckets == NULL
  3312.         && conf->params_source == prev->params_source)
  3313.     {
  3314.         prev->params = conf->params;
  3315. #if (NGX_HTTP_CACHE)
  3316.         prev->params_cache = conf->params_cache;
  3317. #endif
  3318.     }

  3320.     return NGX_CONF_OK;
  3321. }


  3324. static ngx_int_t
  3325. ‌ngx_http_fastcgi_init_params(ngx_conf_t *cf, ngx_http_fastcgi_loc_conf_t *conf,
  3326.     ngx_http_fastcgi_params_t *params, ngx_keyval_t *default_params)
  3327. {
  3328.     u_char                       *p;
  3329.     size_t                        size;
  3330.     uintptr_t                    *code;
  3331.     ngx_uint_t                    i, nsrc;
  3332.     ngx_array_t                   headers_names, params_merged;
  3333.     ngx_keyval_t                 *h;
  3334.     ngx_hash_key_t               *hk;
  3335.     ngx_hash_init_t               hash;
  3336.     ngx_http_upstream_param_t    *src, *s;
  3337.     ngx_http_script_compile_t     sc;
  3338.     ngx_http_script_copy_code_t  *copy;

  3340.     if (params->hash.buckets) {
  3341.         return NGX_OK;
  3342.     }

  3344.     if (conf->params_source == NULL && default_params == NULL) {
  3345.         params->hash.buckets = (void *) 1;
  3346.         return NGX_OK;
  3347.     }

  3349.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  3350.     if (params->lengths == NULL) {
  3351.         return NGX_ERROR;
  3352.     }

  3354.     params->values = ngx_array_create(cf->pool, 512, 1);
  3355.     if (params->values == NULL) {
  3356.         return NGX_ERROR;
  3357.     }

  3359.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  3360.         != NGX_OK)
  3361.     {
  3362.         return NGX_ERROR;
  3363.     }

  3365.     if (conf->params_source) {
  3366.         src = conf->params_source->elts;
  3367.         nsrc = conf->params_source->nelts;

  3369.     } else {
  3370.         src = NULL;
  3371.         nsrc = 0;
  3372.     }

  3374.     if (default_params) {
  3375.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  3376.                            sizeof(ngx_http_upstream_param_t))
  3377.             != NGX_OK)
  3378.         {
  3379.             return NGX_ERROR;
  3380.         }

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

  3384.             s = ngx_array_push(&params_merged);
  3385.             if (s == NULL) {
  3386.                 return NGX_ERROR;
  3387.             }

  3389.             *s = src[i];
  3390.         }

  3392.         h = default_params;

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

  3396.             src = params_merged.elts;
  3397.             nsrc = params_merged.nelts;

  3399.             for (i = 0; i < nsrc; i++) {
  3400.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  3401.                     goto next;
  3402.                 }
  3403.             }

  3405.             s = ngx_array_push(&params_merged);
  3406.             if (s == NULL) {
  3407.                 return NGX_ERROR;
  3408.             }

  3410.             s->key = h->key;
  3411.             s->value = h->value;
  3412.             s->skip_empty = 1;

  3414.         next:

  3416.             h++;
  3417.         }

  3419.         src = params_merged.elts;
  3420.         nsrc = params_merged.nelts;
  3421.     }

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

  3425.         if (src[i].key.len > sizeof("HTTP_") - 1
  3426.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  3427.         {
  3428.             hk = ngx_array_push(&headers_names);
  3429.             if (hk == NULL) {
  3430.                 return NGX_ERROR;
  3431.             }

  3433.             hk->key.len = src[i].key.len - 5;
  3434.             hk->key.data = src[i].key.data + 5;
  3435.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  3436.             hk->value = (void *) 1;

  3438.             if (src[i].value.len == 0) {
  3439.                 continue;
  3440.             }
  3441.         }

  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].key.len;

  3453.         copy = ngx_array_push_n(params->lengths,
  3454.                                 sizeof(ngx_http_script_copy_code_t));
  3455.         if (copy == NULL) {
  3456.             return NGX_ERROR;
  3457.         }

  3459.         copy->code = (ngx_http_script_code_pt) (void *)
  3460.                                                  ngx_http_script_copy_len_code;
  3461.         copy->len = src[i].skip_empty;


  3464.         size = (sizeof(ngx_http_script_copy_code_t)
  3465.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  3466.                & ~(sizeof(uintptr_t) - 1);

  3468.         copy = ngx_array_push_n(params->values, size);
  3469.         if (copy == NULL) {
  3470.             return NGX_ERROR;
  3471.         }

  3473.         copy->code = ngx_http_script_copy_code;
  3474.         copy->len = src[i].key.len;

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


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

  3482.         sc.cf = cf;
  3483.         sc.source = &src[i].value;
  3484.         sc.flushes = &params->flushes;
  3485.         sc.lengths = &params->lengths;
  3486.         sc.values = &params->values;

  3488.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3489.             return NGX_ERROR;
  3490.         }

  3492.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3493.         if (code == NULL) {
  3494.             return NGX_ERROR;
  3495.         }

  3497.         *code = (uintptr_t) NULL;


  3500.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  3501.         if (code == NULL) {
  3502.             return NGX_ERROR;
  3503.         }

  3505.         *code = (uintptr_t) NULL;
  3506.     }

  3508.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3509.     if (code == NULL) {
  3510.         return NGX_ERROR;
  3511.     }

  3513.     *code = (uintptr_t) NULL;

  3515.     params->number = headers_names.nelts;

  3517.     hash.hash = &params->hash;
  3518.     hash.key = ngx_hash_key_lc;
  3519.     hash.max_size = 512;
  3520.     hash.bucket_size = 64;
  3521.     hash.name = "fastcgi_params_hash";
  3522.     hash.pool = cf->pool;
  3523.     hash.temp_pool = NULL;

  3525.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  3526. }


  3529. static ngx_int_t
  3530. ‌ngx_http_fastcgi_script_name_variable(ngx_http_request_t *r,
  3531.     ngx_http_variable_value_t *v, uintptr_t data)
  3532. {
  3533.     u_char                       *p;
  3534.     ngx_http_fastcgi_ctx_t       *f;
  3535.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3537.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3539.     f = ngx_http_fastcgi_split(r, flcf);

  3541.     if (f == NULL) {
  3542.         return NGX_ERROR;
  3543.     }

  3545.     if (f->script_name.len == 0
  3546.         || f->script_name.data[f->script_name.len - 1] != '/')
  3547.     {
  3548.         v->len = f->script_name.len;
  3549.         v->valid = 1;
  3550.         v->no_cacheable = 0;
  3551.         v->not_found = 0;
  3552.         v->data = f->script_name.data;

  3554.         return NGX_OK;
  3555.     }

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

  3559.     v->data = ngx_pnalloc(r->pool, v->len);
  3560.     if (v->data == NULL) {
  3561.         return NGX_ERROR;
  3562.     }

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

  3567.     return NGX_OK;
  3568. }


  3571. static ngx_int_t
  3572. ‌ngx_http_fastcgi_path_info_variable(ngx_http_request_t *r,
  3573.     ngx_http_variable_value_t *v, uintptr_t data)
  3574. {
  3575.     ngx_http_fastcgi_ctx_t       *f;
  3576.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3578.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3580.     f = ngx_http_fastcgi_split(r, flcf);

  3582.     if (f == NULL) {
  3583.         return NGX_ERROR;
  3584.     }

  3586.     v->len = f->path_info.len;
  3587.     v->valid = 1;
  3588.     v->no_cacheable = 0;
  3589.     v->not_found = 0;
  3590.     v->data = f->path_info.data;

  3592.     return NGX_OK;
  3593. }


  3596. static ngx_http_fastcgi_ctx_t *
  3597. ‌ngx_http_fastcgi_split(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  3598. {
  3599.     ngx_http_fastcgi_ctx_t       *f;
  3600. #if (NGX_PCRE)
  3601.     ngx_int_t                     n;
  3602.     int                           captures[(1 + 2) * 3];

  3604.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3606.     if (f == NULL) {
  3607.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3608.         if (f == NULL) {
  3609.             return NULL;
  3610.         }

  3612.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3613.     }

  3615.     if (f->script_name.len) {
  3616.         return f;
  3617.     }

  3619.     if (flcf->split_regex == NULL) {
  3620.         f->script_name = r->uri;
  3621.         return f;
  3622.     }

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

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

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

  3633.         return f;
  3634.     }

  3636.     if (n == NGX_REGEX_NO_MATCHED) {
  3637.         f->script_name = r->uri;
  3638.         return f;
  3639.     }

  3641.     ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  3642.                   ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  3643.                   n, &r->uri, &flcf->split_name);
  3644.     return NULL;

  3646. #else

  3648.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3650.     if (f == NULL) {
  3651.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3652.         if (f == NULL) {
  3653.             return NULL;
  3654.         }

  3656.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3657.     }

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

  3661.     return f;

  3663. #endif
  3664. }


  3667. static char *
  3668. ‌ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3669. {
  3670.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3672.     ngx_url_t                   u;
  3673.     ngx_str_t                  *value, *url;
  3674.     ngx_uint_t                  n;
  3675.     ngx_http_core_loc_conf_t   *clcf;
  3676.     ngx_http_script_compile_t   sc;

  3678.     if (flcf->upstream.upstream || flcf->fastcgi_lengths) {
  3679.         return "is duplicate";
  3680.     }

  3682.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3684.     clcf->handler = ngx_http_fastcgi_handler;

  3686.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  3687.         clcf->auto_redirect = 1;
  3688.     }

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

  3692.     url = &value[1];

  3694.     n = ngx_http_script_variables_count(url);

  3696.     if (n) {

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

  3700.         sc.cf = cf;
  3701.         sc.source = url;
  3702.         sc.lengths = &flcf->fastcgi_lengths;
  3703.         sc.values = &flcf->fastcgi_values;
  3704.         sc.variables = n;
  3705.         sc.complete_lengths = 1;
  3706.         sc.complete_values = 1;

  3708.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3709.             return NGX_CONF_ERROR;
  3710.         }

  3712.         return NGX_CONF_OK;
  3713.     }

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

  3717.     u.url = value[1];
  3718.     u.no_resolve = 1;

  3720.     flcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  3721.     if (flcf->upstream.upstream == NULL) {
  3722.         return NGX_CONF_ERROR;
  3723.     }

  3725.     return NGX_CONF_OK;
  3726. }


  3729. static char *
  3730. ‌ngx_http_fastcgi_split_path_info(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3731. {
  3732. #if (NGX_PCRE)
  3733.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3735.     ngx_str_t            *value;
  3736.     ngx_regex_compile_t   rc;
  3737.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

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

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

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

  3745.     rc.pattern = value[1];
  3746.     rc.pool = cf->pool;
  3747.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3748.     rc.err.data = errstr;

  3750.     if (ngx_regex_compile(&rc) != NGX_OK) {
  3751.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  3752.         return NGX_CONF_ERROR;
  3753.     }

  3755.     if (rc.captures != 2) {
  3756.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3757.                            "pattern \"%V\" must have 2 captures", &value[1]);
  3758.         return NGX_CONF_ERROR;
  3759.     }

  3761.     flcf->split_regex = rc.regex;

  3763.     return NGX_CONF_OK;

  3765. #else

  3767.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3768.                        "\"%V\" requires PCRE library", &cmd->name);
  3769.     return NGX_CONF_ERROR;

  3771. #endif
  3772. }


  3775. static char *
  3776. ‌ngx_http_fastcgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3777. {
  3778.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3780.     ngx_str_t                  *value;
  3781.     ngx_http_script_compile_t   sc;

  3783.     if (flcf->upstream.store != NGX_CONF_UNSET) {
  3784.         return "is duplicate";
  3785.     }

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

  3789.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3790.         flcf->upstream.store = 0;
  3791.         return NGX_CONF_OK;
  3792.     }

  3794.     if (value[1].len == 0) {
  3795.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  3796.         return NGX_CONF_ERROR;
  3797.     }

  3799. #if (NGX_HTTP_CACHE)
  3800.     if (flcf->upstream.cache > 0) {
  3801.         return "is incompatible with \"fastcgi_cache\"";
  3802.     }
  3803. #endif

  3805.     flcf->upstream.store = 1;

  3807.     if (ngx_strcmp(value[1].data, "on") == 0) {
  3808.         return NGX_CONF_OK;
  3809.     }

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

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

  3816.     sc.cf = cf;
  3817.     sc.source = &value[1];
  3818.     sc.lengths = &flcf->upstream.store_lengths;
  3819.     sc.values = &flcf->upstream.store_values;
  3820.     sc.variables = ngx_http_script_variables_count(&value[1]);
  3821.     sc.complete_lengths = 1;
  3822.     sc.complete_values = 1;

  3824.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  3825.         return NGX_CONF_ERROR;
  3826.     }

  3828.     return NGX_CONF_OK;
  3829. }


  3832. #if (NGX_HTTP_CACHE)

  3834. static char *
  3835. ‌ngx_http_fastcgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3836. {
  3837.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3839.     ngx_str_t                         *value;
  3840.     ngx_http_complex_value_t           cv;
  3841.     ngx_http_compile_complex_value_t   ccv;

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

  3845.     if (flcf->upstream.cache != NGX_CONF_UNSET) {
  3846.         return "is duplicate";
  3847.     }

  3849.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3850.         flcf->upstream.cache = 0;
  3851.         return NGX_CONF_OK;
  3852.     }

  3854.     if (flcf->upstream.store > 0) {
  3855.         return "is incompatible with \"fastcgi_store\"";
  3856.     }

  3858.     flcf->upstream.cache = 1;

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

  3862.     ccv.cf = cf;
  3863.     ccv.value = &value[1];
  3864.     ccv.complex_value = &cv;

  3866.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3867.         return NGX_CONF_ERROR;
  3868.     }

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

  3872.         flcf->upstream.cache_value = ngx_palloc(cf->pool,
  3873.                                              sizeof(ngx_http_complex_value_t));
  3874.         if (flcf->upstream.cache_value == NULL) {
  3875.             return NGX_CONF_ERROR;
  3876.         }

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

  3880.         return NGX_CONF_OK;
  3881.     }

  3883.     flcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  3884.                                                       &ngx_http_fastcgi_module);
  3885.     if (flcf->upstream.cache_zone == NULL) {
  3886.         return NGX_CONF_ERROR;
  3887.     }

  3889.     return NGX_CONF_OK;
  3890. }


  3893. static char *
  3894. ‌ngx_http_fastcgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3895. {
  3896.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3898.     ngx_str_t                         *value;
  3899.     ngx_http_compile_complex_value_t   ccv;

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

  3903.     if (flcf->cache_key.value.data) {
  3904.         return "is duplicate";
  3905.     }

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

  3909.     ccv.cf = cf;
  3910.     ccv.value = &value[1];
  3911.     ccv.complex_value = &flcf->cache_key;

  3913.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3914.         return NGX_CONF_ERROR;
  3915.     }

  3917.     return NGX_CONF_OK;
  3918. }

  3920. #endif


  3923. static char *
  3924. ‌ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post, void *data)
  3925. {
  3926. #if (NGX_FREEBSD)
  3927.     ssize_t *np = data;

  3929.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  3930.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3931.                            "\"fastcgi_send_lowat\" must be less than %d "
  3932.                            "(sysctl net.inet.tcp.sendspace)",
  3933.                            ngx_freebsd_net_inet_tcp_sendspace);

  3935.         return NGX_CONF_ERROR;
  3936.     }

  3938. #elif !(NGX_HAVE_SO_SNDLOWAT)
  3939.     ssize_t *np = data;

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

  3944.     *np = 0;

  3946. #endif

  3948.     return NGX_CONF_OK;
  3949. }

One Level Up Top Level