One Level Up Top Level

src/http/modules/ngx_http_fastcgi_module.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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


  13. ‌typedef struct {
  14.     ngx_array_t                    caches;  /* ngx_http_file_cache_t * */
  15. ‌} ngx_http_fastcgi_main_conf_t;


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


  27. ‌typedef struct {
  28.     ngx_http_upstream_conf_t       upstream;

  30.     ngx_str_t                      index;

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

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

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

  43.     ngx_flag_t                     keep_conn;

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

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


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


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


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

  84.     off_t                          rest;

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

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

  94.     ngx_array_t                   *split_parts;

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


  101. ‌#define NGX_HTTP_FASTCGI_RESPONDER      1

  103. ‌#define NGX_HTTP_FASTCGI_KEEP_CONN      1

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


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


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


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


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


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

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

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

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

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


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


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


  224. ‌ngx_module_t  ngx_http_fastcgi_module;


  227. ‌static ngx_command_t  ngx_http_fastcgi_commands[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  397. #if (NGX_HTTP_CACHE)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  504. #endif

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

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

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

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

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

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

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

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

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

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

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

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

  590.       ngx_null_command
  591. };


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

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

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

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


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


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

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

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

  645. };


  648. ‌static ngx_http_variable_t  ngx_http_fastcgi_vars[] = {

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

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

  658.       ngx_http_null_variable
  659. };


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


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


  680. #if (NGX_HTTP_CACHE)

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

  695. #endif


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


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

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

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

  723.     ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);

  725.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

  733.     u = r->upstream;

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

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

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

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

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

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

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

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

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

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

  774.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

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

  780.     return NGX_DONE;
  781. }


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

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

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

  799.     url.no_resolve = 1;

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

  807.         return NGX_ERROR;
  808.     }

  810.     u = r->upstream;

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

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

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

  828.     return NGX_OK;
  829. }


  832. #if (NGX_HTTP_CACHE)

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

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

  845.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

  851.     return NGX_OK;
  852. }

  854. #endif


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

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

  882.     u = r->upstream;

  884.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

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

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

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

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

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

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

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

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

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

  921.         len += params_len;
  922.     }

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

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

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

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

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

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

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

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

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

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

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

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

  978.                 hash = 0;

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

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

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

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

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

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

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

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

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

  1012.         next_length:

  1014.             continue;
  1015.         }
  1016.     }


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


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


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

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

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


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

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

  1050.     cl->buf = b;

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

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

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

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

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


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

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

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

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

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

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

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

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

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

  1105.                 e.skip = 0;

  1107.                 continue;
  1108.             }

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

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

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

  1124.             } else {
  1125.                 *e.pos++ = (u_char) val_len;
  1126.             }

  1128.             while (*(uintptr_t *) e.ip) {
  1129.                 code = *(ngx_http_script_code_pt *) e.ip;
  1130.                 code((ngx_http_script_engine_t *) &e);
  1131.             }
  1132.             e.ip += sizeof(uintptr_t);

  1134.             if (e.status) {
  1135.                 return NGX_ERROR;
  1136.             }

  1138.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1139.                            "fastcgi param: \"%*s: %*s\"",
  1140.                            key_len, e.pos - (key_len + val_len),
  1141.                            val_len, e.pos - val_len);
  1142.         }

  1144.         if (e.pos != e.end) {
  1145.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1146.                           "fastcgi request length mismatch");
  1147.             return NGX_ERROR;
  1148.         }

  1150.         b->last = e.pos;
  1151.     }


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

  1156.         part = &r->headers_in.headers.part;
  1157.         header = part->elts;

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

  1161.             if (i >= part->nelts) {
  1162.                 if (part->next == NULL) {
  1163.                     break;
  1164.                 }

  1166.                 part = part->next;
  1167.                 header = part->elts;
  1168.                 i = 0;
  1169.             }

  1171.             for (n = 0; n < header_params; n++) {
  1172.                 if (&header[i] == ignored[n]) {
  1173.                     goto next_value;
  1174.                 }
  1175.             }

  1177.             key_len = sizeof("HTTP_") - 1 + header[i].key.len;
  1178.             if (key_len > 127) {
  1179.                 *b->last++ = (u_char) (((key_len >> 24) & 0x7f) | 0x80);
  1180.                 *b->last++ = (u_char) ((key_len >> 16) & 0xff);
  1181.                 *b->last++ = (u_char) ((key_len >> 8) & 0xff);
  1182.                 *b->last++ = (u_char) (key_len & 0xff);

  1184.             } else {
  1185.                 *b->last++ = (u_char) key_len;
  1186.             }

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

  1190.             for (hn = header[i].next; hn; hn = hn->next) {
  1191.                 val_len += hn->value.len + 2;
  1192.             }

  1194.             if (val_len > 127) {
  1195.                 *b->last++ = (u_char) (((val_len >> 24) & 0x7f) | 0x80);
  1196.                 *b->last++ = (u_char) ((val_len >> 16) & 0xff);
  1197.                 *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1198.                 *b->last++ = (u_char) (val_len & 0xff);

  1200.             } else {
  1201.                 *b->last++ = (u_char) val_len;
  1202.             }

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

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

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

  1212.                 } else if (ch == '-') {
  1213.                     ch = '_';
  1214.                 }

  1216.                 *b->last++ = ch;
  1217.             }

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

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

  1224.                 if (header[i].key.len == sizeof("Cookie") - 1
  1225.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1226.                                        sizeof("Cookie") - 1)
  1227.                        == 0)
  1228.                 {
  1229.                     sep = ';';

  1231.                 } else {
  1232.                     sep = ',';
  1233.                 }

  1235.                 for (hn = header[i].next; hn; hn = hn->next) {
  1236.                     *b->last++ = sep;
  1237.                     *b->last++ = ' ';
  1238.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1239.                 }
  1240.             }

  1242.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1243.                            "fastcgi param: \"%*s: %*s\"",
  1244.                            key_len, b->last - (key_len + val_len),
  1245.                            val_len, b->last - val_len);
  1246.         next_value:

  1248.             continue;
  1249.         }
  1250.     }


  1253.     if (padding) {
  1254.         ngx_memzero(b->last, padding);
  1255.         b->last += padding;
  1256.     }


  1259.     h = (ngx_http_fastcgi_header_t *) b->last;
  1260.     b->last += sizeof(ngx_http_fastcgi_header_t);

  1262.     h->version = 1;
  1263.     h->type = NGX_HTTP_FASTCGI_PARAMS;
  1264.     h->request_id_hi = 0;
  1265.     h->request_id_lo = 1;
  1266.     h->content_length_hi = 0;
  1267.     h->content_length_lo = 0;
  1268.     h->padding_length = 0;
  1269.     h->reserved = 0;

  1271.     if (r->request_body_no_buffering) {

  1273.         u->request_bufs = cl;

  1275.         u->output.output_filter = ngx_http_fastcgi_body_output_filter;
  1276.         u->output.filter_ctx = r;

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

  1280.         body = u->request_bufs;
  1281.         u->request_bufs = cl;

  1283. #if (NGX_SUPPRESS_WARN)
  1284.         file_pos = 0;
  1285.         pos = NULL;
  1286. #endif

  1288.         while (body) {

  1290.             if (ngx_buf_special(body->buf)) {
  1291.                 body = body->next;
  1292.                 continue;
  1293.             }

  1295.             if (body->buf->in_file) {
  1296.                 file_pos = body->buf->file_pos;

  1298.             } else {
  1299.                 pos = body->buf->pos;
  1300.             }

  1302.             next = 0;

  1304.             do {
  1305.                 b = ngx_alloc_buf(r->pool);
  1306.                 if (b == NULL) {
  1307.                     return NGX_ERROR;
  1308.                 }

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

  1312.                 if (body->buf->in_file) {
  1313.                     b->file_pos = file_pos;
  1314.                     file_pos += 32 * 1024;

  1316.                     if (file_pos >= body->buf->file_last) {
  1317.                         file_pos = body->buf->file_last;
  1318.                         next = 1;
  1319.                     }

  1321.                     b->file_last = file_pos;
  1322.                     len = (ngx_uint_t) (file_pos - b->file_pos);

  1324.                 } else {
  1325.                     b->pos = pos;
  1326.                     b->start = pos;
  1327.                     pos += 32 * 1024;

  1329.                     if (pos >= body->buf->last) {
  1330.                         pos = body->buf->last;
  1331.                         next = 1;
  1332.                     }

  1334.                     b->last = pos;
  1335.                     len = (ngx_uint_t) (pos - b->pos);
  1336.                 }

  1338.                 padding = 8 - len % 8;
  1339.                 padding = (padding == 8) ? 0 : padding;

  1341.                 h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1342.                 cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1344.                 h->version = 1;
  1345.                 h->type = NGX_HTTP_FASTCGI_STDIN;
  1346.                 h->request_id_hi = 0;
  1347.                 h->request_id_lo = 1;
  1348.                 h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1349.                 h->content_length_lo = (u_char) (len & 0xff);
  1350.                 h->padding_length = (u_char) padding;
  1351.                 h->reserved = 0;

  1353.                 cl->next = ngx_alloc_chain_link(r->pool);
  1354.                 if (cl->next == NULL) {
  1355.                     return NGX_ERROR;
  1356.                 }

  1358.                 cl = cl->next;
  1359.                 cl->buf = b;

  1361.                 b = ngx_create_temp_buf(r->pool,
  1362.                                         sizeof(ngx_http_fastcgi_header_t)
  1363.                                         + padding);
  1364.                 if (b == NULL) {
  1365.                     return NGX_ERROR;
  1366.                 }

  1368.                 if (padding) {
  1369.                     ngx_memzero(b->last, padding);
  1370.                     b->last += padding;
  1371.                 }

  1373.                 cl->next = ngx_alloc_chain_link(r->pool);
  1374.                 if (cl->next == NULL) {
  1375.                     return NGX_ERROR;
  1376.                 }

  1378.                 cl = cl->next;
  1379.                 cl->buf = b;

  1381.             } while (!next);

  1383.             body = body->next;
  1384.         }

  1386.     } else {
  1387.         u->request_bufs = cl;
  1388.     }

  1390.     if (!r->request_body_no_buffering) {
  1391.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1392.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1394.         h->version = 1;
  1395.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1396.         h->request_id_hi = 0;
  1397.         h->request_id_lo = 1;
  1398.         h->content_length_hi = 0;
  1399.         h->content_length_lo = 0;
  1400.         h->padding_length = 0;
  1401.         h->reserved = 0;
  1402.     }

  1404.     cl->next = NULL;

  1406.     return NGX_OK;
  1407. }


  1410. static ngx_int_t
  1411. ‌ngx_http_fastcgi_reinit_request(ngx_http_request_t *r)
  1412. {
  1413.     ngx_http_fastcgi_ctx_t  *f;

  1415.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1417.     if (f == NULL) {
  1418.         return NGX_OK;
  1419.     }

  1421.     f->state = ngx_http_fastcgi_st_version;
  1422.     f->fastcgi_stdout = 0;
  1423.     f->large_stderr = 0;

  1425.     if (f->split_parts) {
  1426.         f->split_parts->nelts = 0;
  1427.     }

  1429.     r->state = 0;

  1431.     return NGX_OK;
  1432. }


  1435. static ngx_int_t
  1436. ‌ngx_http_fastcgi_body_output_filter(void *data, ngx_chain_t *in)
  1437. {
  1438.     ngx_http_request_t  *r = data;

  1440.     off_t                       file_pos;
  1441.     u_char                     *pos, *start;
  1442.     size_t                      len, padding;
  1443.     ngx_buf_t                  *b;
  1444.     ngx_int_t                   rc;
  1445.     ngx_uint_t                  next, last;
  1446.     ngx_chain_t                *cl, *tl, *out, **ll;
  1447.     ngx_http_fastcgi_ctx_t     *f;
  1448.     ngx_http_fastcgi_header_t  *h;

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

  1453.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1455.     if (in == NULL) {
  1456.         out = in;
  1457.         goto out;
  1458.     }

  1460.     out = NULL;
  1461.     ll = &out;

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

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

  1469.         f->header_sent = 1;

  1471.         tl = ngx_alloc_chain_link(r->pool);
  1472.         if (tl == NULL) {
  1473.             return NGX_ERROR;
  1474.         }

  1476.         tl->buf = in->buf;
  1477.         *ll = tl;
  1478.         ll = &tl->next;

  1480.         in = in->next;

  1482.         if (in == NULL) {
  1483.             tl->next = NULL;
  1484.             goto out;
  1485.         }
  1486.     }

  1488.     cl = ngx_chain_get_free_buf(r->pool, &f->free);
  1489.     if (cl == NULL) {
  1490.         return NGX_ERROR;
  1491.     }

  1493.     b = cl->buf;

  1495.     b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1496.     b->temporary = 1;

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

  1501.         b->start = ngx_palloc(r->pool,
  1502.                               sizeof(ngx_http_fastcgi_header_t) + 7);
  1503.         if (b->start == NULL) {
  1504.             return NGX_ERROR;
  1505.         }

  1507.         b->pos = b->start;
  1508.         b->last = b->start;

  1510.         b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1511.     }

  1513.     *ll = cl;

  1515.     last = 0;
  1516.     padding = 0;

  1518. #if (NGX_SUPPRESS_WARN)
  1519.     file_pos = 0;
  1520.     pos = NULL;
  1521. #endif

  1523.     while (in) {

  1525.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1526.                        "fastcgi output in  l:%d f:%d %p, pos %p, size: %z "
  1527.                        "file: %O, size: %O",
  1528.                        in->buf->last_buf,
  1529.                        in->buf->in_file,
  1530.                        in->buf->start, in->buf->pos,
  1531.                        in->buf->last - in->buf->pos,
  1532.                        in->buf->file_pos,
  1533.                        in->buf->file_last - in->buf->file_pos);

  1535.         if (in->buf->last_buf) {
  1536.             last = 1;
  1537.         }

  1539.         if (ngx_buf_special(in->buf)) {
  1540.             in = in->next;
  1541.             continue;
  1542.         }

  1544.         if (in->buf->in_file) {
  1545.             file_pos = in->buf->file_pos;

  1547.         } else {
  1548.             pos = in->buf->pos;
  1549.         }

  1551.         next = 0;

  1553.         do {
  1554.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1555.             if (tl == NULL) {
  1556.                 return NGX_ERROR;
  1557.             }

  1559.             b = tl->buf;
  1560.             start = b->start;

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

  1564.             /*
  1565.              * restore b->start to preserve memory allocated in the buffer,
  1566.              * to reuse it later for headers and padding
  1567.              */

  1569.             b->start = start;

  1571.             if (in->buf->in_file) {
  1572.                 b->file_pos = file_pos;
  1573.                 file_pos += 32 * 1024;

  1575.                 if (file_pos >= in->buf->file_last) {
  1576.                     file_pos = in->buf->file_last;
  1577.                     next = 1;
  1578.                 }

  1580.                 b->file_last = file_pos;
  1581.                 len = (ngx_uint_t) (file_pos - b->file_pos);

  1583.             } else {
  1584.                 b->pos = pos;
  1585.                 pos += 32 * 1024;

  1587.                 if (pos >= in->buf->last) {
  1588.                     pos = in->buf->last;
  1589.                     next = 1;
  1590.                 }

  1592.                 b->last = pos;
  1593.                 len = (ngx_uint_t) (pos - b->pos);
  1594.             }

  1596.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1597.             b->shadow = in->buf;
  1598.             b->last_shadow = next;

  1600.             b->last_buf = 0;
  1601.             b->last_in_chain = 0;

  1603.             padding = 8 - len % 8;
  1604.             padding = (padding == 8) ? 0 : padding;

  1606.             h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1607.             cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1609.             h->version = 1;
  1610.             h->type = NGX_HTTP_FASTCGI_STDIN;
  1611.             h->request_id_hi = 0;
  1612.             h->request_id_lo = 1;
  1613.             h->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1614.             h->content_length_lo = (u_char) (len & 0xff);
  1615.             h->padding_length = (u_char) padding;
  1616.             h->reserved = 0;

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

  1621.             tl = ngx_chain_get_free_buf(r->pool, &f->free);
  1622.             if (tl == NULL) {
  1623.                 return NGX_ERROR;
  1624.             }

  1626.             b = tl->buf;

  1628.             b->tag = (ngx_buf_tag_t) &ngx_http_fastcgi_body_output_filter;
  1629.             b->temporary = 1;

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

  1634.                 b->start = ngx_palloc(r->pool,
  1635.                                       sizeof(ngx_http_fastcgi_header_t) + 7);
  1636.                 if (b->start == NULL) {
  1637.                     return NGX_ERROR;
  1638.                 }

  1640.                 b->pos = b->start;
  1641.                 b->last = b->start;

  1643.                 b->end = b->start + sizeof(ngx_http_fastcgi_header_t) + 7;
  1644.             }

  1646.             if (padding) {
  1647.                 ngx_memzero(b->last, padding);
  1648.                 b->last += padding;
  1649.             }

  1651.             cl->next = tl;
  1652.             cl = tl;

  1654.         } while (!next);

  1656.         in = in->next;
  1657.     }

  1659.     if (last) {
  1660.         h = (ngx_http_fastcgi_header_t *) cl->buf->last;
  1661.         cl->buf->last += sizeof(ngx_http_fastcgi_header_t);

  1663.         h->version = 1;
  1664.         h->type = NGX_HTTP_FASTCGI_STDIN;
  1665.         h->request_id_hi = 0;
  1666.         h->request_id_lo = 1;
  1667.         h->content_length_hi = 0;
  1668.         h->content_length_lo = 0;
  1669.         h->padding_length = 0;
  1670.         h->reserved = 0;

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

  1674.     } else if (padding == 0) {
  1675.         /* TODO: do not allocate buffers instead */
  1676.         cl->buf->temporary = 0;
  1677.         cl->buf->sync = 1;
  1678.     }

  1680.     cl->next = NULL;

  1682. out:

  1684. #if (NGX_DEBUG)

  1686.     for (cl = out; cl; cl = cl->next) {
  1687.         ngx_log_debug7(NGX_LOG_DEBUG_EVENT, r->connection->log, 0,
  1688.                        "fastcgi output out l:%d f:%d %p, pos %p, size: %z "
  1689.                        "file: %O, size: %O",
  1690.                        cl->buf->last_buf,
  1691.                        cl->buf->in_file,
  1692.                        cl->buf->start, cl->buf->pos,
  1693.                        cl->buf->last - cl->buf->pos,
  1694.                        cl->buf->file_pos,
  1695.                        cl->buf->file_last - cl->buf->file_pos);
  1696.     }

  1698. #endif

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

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

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

  1707.         /* mark original buffers as sent */

  1709.         if (cl->buf->shadow) {
  1710.             if (cl->buf->last_shadow) {
  1711.                 b = cl->buf->shadow;
  1712.                 b->pos = b->last;
  1713.             }

  1715.             cl->buf->shadow = NULL;
  1716.         }
  1717.     }

  1719.     return rc;
  1720. }


  1723. static ngx_int_t
  1724. ‌ngx_http_fastcgi_process_header(ngx_http_request_t *r)
  1725. {
  1726.     u_char                         *p, *msg, *start, *last,
  1727.                                    *part_start, *part_end;
  1728.     size_t                          size;
  1729.     ngx_str_t                      *status_line, *pattern;
  1730.     ngx_int_t                       rc, status;
  1731.     ngx_buf_t                       buf;
  1732.     ngx_uint_t                      i;
  1733.     ngx_table_elt_t                *h;
  1734.     ngx_http_upstream_t            *u;
  1735.     ngx_http_fastcgi_ctx_t         *f;
  1736.     ngx_http_upstream_header_t     *hh;
  1737.     ngx_http_fastcgi_loc_conf_t    *flcf;
  1738.     ngx_http_fastcgi_split_part_t  *part;
  1739.     ngx_http_upstream_main_conf_t  *umcf;

  1741.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  1743.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1745.     u = r->upstream;

  1747.     for ( ;; ) {

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

  1751.             f->pos = u->buffer.pos;
  1752.             f->last = u->buffer.last;

  1754.             rc = ngx_http_fastcgi_process_record(r, f);

  1756.             u->buffer.pos = f->pos;
  1757.             u->buffer.last = f->last;

  1759.             if (rc == NGX_AGAIN) {
  1760.                 return NGX_AGAIN;
  1761.             }

  1763.             if (rc == NGX_ERROR) {
  1764.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1765.             }

  1767.             if (f->type != NGX_HTTP_FASTCGI_STDOUT
  1768.                 && f->type != NGX_HTTP_FASTCGI_STDERR)
  1769.             {
  1770.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1771.                               "upstream sent unexpected FastCGI record: %ui",
  1772.                               f->type);

  1774.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1775.             }

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

  1781.                 return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1782.             }
  1783.         }

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

  1787.             if (u->buffer.pos + f->padding < u->buffer.last) {
  1788.                 f->state = ngx_http_fastcgi_st_version;
  1789.                 u->buffer.pos += f->padding;

  1791.                 continue;
  1792.             }

  1794.             if (u->buffer.pos + f->padding == u->buffer.last) {
  1795.                 f->state = ngx_http_fastcgi_st_version;
  1796.                 u->buffer.pos = u->buffer.last;

  1798.                 return NGX_AGAIN;
  1799.             }

  1801.             f->padding -= u->buffer.last - u->buffer.pos;
  1802.             u->buffer.pos = u->buffer.last;

  1804.             return NGX_AGAIN;
  1805.         }


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

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

  1812.             if (f->length) {
  1813.                 msg = u->buffer.pos;

  1815.                 if (u->buffer.pos + f->length <= u->buffer.last) {
  1816.                     u->buffer.pos += f->length;
  1817.                     f->length = 0;
  1818.                     f->state = ngx_http_fastcgi_st_padding;

  1820.                 } else {
  1821.                     f->length -= u->buffer.last - u->buffer.pos;
  1822.                     u->buffer.pos = u->buffer.last;
  1823.                 }

  1825.                 for (p = u->buffer.pos - 1; msg < p; p--) {
  1826.                     if (*p != LF && *p != CR && *p != '.' && *p != ' ') {
  1827.                         break;
  1828.                     }
  1829.                 }

  1831.                 p++;

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

  1836.                 flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  1838.                 if (flcf->catch_stderr) {
  1839.                     pattern = flcf->catch_stderr->elts;

  1841.                     for (i = 0; i < flcf->catch_stderr->nelts; i++) {
  1842.                         if (ngx_strnstr(msg, (char *) pattern[i].data,
  1843.                                         p - msg)
  1844.                             != NULL)
  1845.                         {
  1846.                             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1847.                         }
  1848.                     }
  1849.                 }

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

  1853.                     if (!f->fastcgi_stdout) {

  1855.                         /*
  1856.                          * the special handling the large number
  1857.                          * of the PHP warnings to not allocate memory
  1858.                          */

  1860. #if (NGX_HTTP_CACHE)
  1861.                         if (r->cache) {
  1862.                             u->buffer.pos = u->buffer.start
  1863.                                                      + r->cache->header_start;
  1864.                         } else {
  1865.                             u->buffer.pos = u->buffer.start;
  1866.                         }
  1867. #else
  1868.                         u->buffer.pos = u->buffer.start;
  1869. #endif
  1870.                         u->buffer.last = u->buffer.pos;
  1871.                         f->large_stderr = 1;
  1872.                     }

  1874.                     return NGX_AGAIN;
  1875.                 }

  1877.             } else {
  1878.                 f->state = ngx_http_fastcgi_st_padding;
  1879.             }

  1881.             continue;
  1882.         }


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

  1887. #if (NGX_HTTP_CACHE)

  1889.         if (f->large_stderr && r->cache) {
  1890.             ssize_t                     len;
  1891.             ngx_http_fastcgi_header_t  *fh;

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

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

  1897.             /*
  1898.              * A tail of large stderr output before HTTP header is placed
  1899.              * in a cache file without a FastCGI record header.
  1900.              * To workaround it we put a dummy FastCGI record header at the
  1901.              * start of the stderr output or update r->cache_header_start,
  1902.              * if there is no enough place for the record header.
  1903.              */

  1905.             if (len >= 0) {
  1906.                 fh = (ngx_http_fastcgi_header_t *) start;
  1907.                 fh->version = 1;
  1908.                 fh->type = NGX_HTTP_FASTCGI_STDERR;
  1909.                 fh->request_id_hi = 0;
  1910.                 fh->request_id_lo = 1;
  1911.                 fh->content_length_hi = (u_char) ((len >> 8) & 0xff);
  1912.                 fh->content_length_lo = (u_char) (len & 0xff);
  1913.                 fh->padding_length = 0;
  1914.                 fh->reserved = 0;

  1916.             } else {
  1917.                 r->cache->header_start += u->buffer.pos - start
  1918.                                           - sizeof(ngx_http_fastcgi_header_t);
  1919.             }

  1921.             f->large_stderr = 0;
  1922.         }

  1924. #endif

  1926.         f->fastcgi_stdout = 1;

  1928.         start = u->buffer.pos;

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

  1932.             /*
  1933.              * set u->buffer.last to the end of the FastCGI record data
  1934.              * for ngx_http_parse_header_line()
  1935.              */

  1937.             last = u->buffer.last;
  1938.             u->buffer.last = u->buffer.pos + f->length;

  1940.         } else {
  1941.             last = NULL;
  1942.         }

  1944.         for ( ;; ) {

  1946.             part_start = u->buffer.pos;
  1947.             part_end = u->buffer.last;

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

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

  1954.             if (rc == NGX_AGAIN) {
  1955.                 break;
  1956.             }

  1958.             if (rc == NGX_OK) {

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

  1962.                 h = ngx_list_push(&u->headers_in.headers);
  1963.                 if (h == NULL) {
  1964.                     return NGX_ERROR;
  1965.                 }

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

  1969.                     part = f->split_parts->elts;
  1970.                     size = u->buffer.pos - part_start;

  1972.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1973.                         size += part[i].end - part[i].start;
  1974.                     }

  1976.                     p = ngx_pnalloc(r->pool, size);
  1977.                     if (p == NULL) {
  1978.                         h->hash = 0;
  1979.                         return NGX_ERROR;
  1980.                     }

  1982.                     buf.pos = p;

  1984.                     for (i = 0; i < f->split_parts->nelts; i++) {
  1985.                         p = ngx_cpymem(p, part[i].start,
  1986.                                        part[i].end - part[i].start);
  1987.                     }

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

  1991.                     buf.last = p;

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

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

  1997.                     if (rc != NGX_OK) {
  1998.                         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1999.                                       "invalid header after joining "
  2000.                                       "FastCGI records");
  2001.                         h->hash = 0;
  2002.                         return NGX_ERROR;
  2003.                     }

  2005.                     h->key.len = r->header_name_end - r->header_name_start;
  2006.                     h->key.data = r->header_name_start;
  2007.                     h->key.data[h->key.len] = '\0';

  2009.                     h->value.len = r->header_end - r->header_start;
  2010.                     h->value.data = r->header_start;
  2011.                     h->value.data[h->value.len] = '\0';

  2013.                     h->lowcase_key = ngx_pnalloc(r->pool, h->key.len);
  2014.                     if (h->lowcase_key == NULL) {
  2015.                         return NGX_ERROR;
  2016.                     }

  2018.                 } else {

  2020.                     h->key.len = r->header_name_end - r->header_name_start;
  2021.                     h->value.len = r->header_end - r->header_start;

  2023.                     h->key.data = ngx_pnalloc(r->pool,
  2024.                                               h->key.len + 1 + h->value.len + 1
  2025.                                               + h->key.len);
  2026.                     if (h->key.data == NULL) {
  2027.                         h->hash = 0;
  2028.                         return NGX_ERROR;
  2029.                     }

  2031.                     h->value.data = h->key.data + h->key.len + 1;
  2032.                     h->lowcase_key = h->key.data + h->key.len + 1
  2033.                                      + h->value.len + 1;

  2035.                     ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  2036.                     h->key.data[h->key.len] = '\0';
  2037.                     ngx_memcpy(h->value.data, r->header_start, h->value.len);
  2038.                     h->value.data[h->value.len] = '\0';
  2039.                 }

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

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

  2046.                 } else {
  2047.                     ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  2048.                 }

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

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

  2056.                     if (rc != NGX_OK) {
  2057.                         return rc;
  2058.                     }
  2059.                 }

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

  2065.                 if (u->buffer.pos < u->buffer.last) {
  2066.                     continue;
  2067.                 }

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

  2071.                 break;
  2072.             }

  2074.             if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  2081.                 if (u->headers_in.status) {
  2082.                     status_line = &u->headers_in.status->value;

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

  2086.                     if (status == NGX_ERROR) {
  2087.                         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2088.                                       "upstream sent invalid status \"%V\"",
  2089.                                       status_line);
  2090.                         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2091.                     }

  2093.                     u->headers_in.status_n = status;

  2095.                     if (status_line->len > 3) {
  2096.                         u->headers_in.status_line = *status_line;
  2097.                     }

  2099.                 } else if (u->headers_in.location) {
  2100.                     u->headers_in.status_n = 302;
  2101.                     ngx_str_set(&u->headers_in.status_line,
  2102.                                 "302 Moved Temporarily");

  2104.                 } else {
  2105.                     u->headers_in.status_n = 200;
  2106.                     ngx_str_set(&u->headers_in.status_line, "200 OK");
  2107.                 }

  2109.                 if (u->state && u->state->status == 0) {
  2110.                     u->state->status = u->headers_in.status_n;
  2111.                 }

  2113.                 break;
  2114.             }

  2116.             /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  2118.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2119.                           "upstream sent invalid header: \"%*s\\x%02xd...\"",
  2120.                           r->header_end - r->header_name_start,
  2121.                           r->header_name_start, *r->header_end);

  2123.             return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  2124.         }

  2126.         if (last) {
  2127.             u->buffer.last = last;
  2128.         }

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

  2132.         if (f->length == 0) {
  2133.             f->state = ngx_http_fastcgi_st_padding;
  2134.         }

  2136.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
  2137.             return NGX_OK;
  2138.         }

  2140.         if (rc == NGX_OK) {
  2141.             continue;
  2142.         }

  2144.         /* rc == NGX_AGAIN */

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

  2149.         if (f->split_parts == NULL) {
  2150.             f->split_parts = ngx_array_create(r->pool, 1,
  2151.                                         sizeof(ngx_http_fastcgi_split_part_t));
  2152.             if (f->split_parts == NULL) {
  2153.                 return NGX_ERROR;
  2154.             }
  2155.         }

  2157.         part = ngx_array_push(f->split_parts);
  2158.         if (part == NULL) {
  2159.             return NGX_ERROR;
  2160.         }

  2162.         part->start = part_start;
  2163.         part->end = part_end;

  2165.         if (u->buffer.pos < u->buffer.last) {
  2166.             continue;
  2167.         }

  2169.         return NGX_AGAIN;
  2170.     }
  2171. }


  2174. static ngx_int_t
  2175. ‌ngx_http_fastcgi_input_filter_init(void *data)
  2176. {
  2177.     ngx_http_request_t  *r = data;

  2179.     ngx_http_upstream_t          *u;
  2180.     ngx_http_fastcgi_ctx_t       *f;
  2181.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2183.     u = r->upstream;

  2185.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2186.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

  2191.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  2192.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  2193.     {
  2194.         f->rest = 0;

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

  2199.     } else {
  2200.         f->rest = u->headers_in.content_length_n;
  2201.     }

  2203.     return NGX_OK;
  2204. }


  2207. static ngx_int_t
  2208. ‌ngx_http_fastcgi_input_filter(ngx_event_pipe_t *p, ngx_buf_t *buf)
  2209. {
  2210.     u_char                       *m, *msg;
  2211.     ngx_int_t                     rc;
  2212.     ngx_buf_t                    *b, **prev;
  2213.     ngx_chain_t                  *cl;
  2214.     ngx_http_request_t           *r;
  2215.     ngx_http_fastcgi_ctx_t       *f;
  2216.     ngx_http_fastcgi_loc_conf_t  *flcf;

  2218.     if (buf->pos == buf->last) {
  2219.         return NGX_OK;
  2220.     }

  2222.     r = p->input_ctx;
  2223.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);
  2224.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

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

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

  2232.         return NGX_OK;
  2233.     }

  2235.     b = NULL;
  2236.     prev = &buf->shadow;

  2238.     f->pos = buf->pos;
  2239.     f->last = buf->last;

  2241.     for ( ;; ) {
  2242.         if (f->state < ngx_http_fastcgi_st_data) {

  2244.             rc = ngx_http_fastcgi_process_record(r, f);

  2246.             if (rc == NGX_AGAIN) {
  2247.                 break;
  2248.             }

  2250.             if (rc == NGX_ERROR) {
  2251.                 return NGX_ERROR;
  2252.             }

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

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

  2260.                 if (f->rest > 0) {
  2261.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2262.                                   "upstream prematurely closed "
  2263.                                   "FastCGI stdout");

  2265.                     p->upstream_error = 1;
  2266.                     p->upstream_eof = 0;
  2267.                     f->closed = 1;

  2269.                     break;
  2270.                 }

  2272.                 if (!flcf->keep_conn) {
  2273.                     p->upstream_done = 1;
  2274.                 }

  2276.                 continue;
  2277.             }

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

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

  2284.                 if (f->rest > 0) {
  2285.                     ngx_log_error(NGX_LOG_ERR, p->log, 0,
  2286.                                   "upstream prematurely closed "
  2287.                                   "FastCGI request");

  2289.                     p->upstream_error = 1;
  2290.                     p->upstream_eof = 0;
  2291.                     f->closed = 1;

  2293.                     break;
  2294.                 }

  2296.                 if (!flcf->keep_conn) {
  2297.                     p->upstream_done = 1;
  2298.                     break;
  2299.                 }

  2301.                 continue;
  2302.             }
  2303.         }


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

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

  2310.                 if (f->pos + f->padding < f->last) {
  2311.                     p->upstream_done = 1;
  2312.                     break;
  2313.                 }

  2315.                 if (f->pos + f->padding == f->last) {
  2316.                     p->upstream_done = 1;
  2317.                     r->upstream->keepalive = 1;
  2318.                     break;
  2319.                 }

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

  2323.                 break;
  2324.             }

  2326.             if (f->pos + f->padding < f->last) {
  2327.                 f->state = ngx_http_fastcgi_st_version;
  2328.                 f->pos += f->padding;

  2330.                 continue;
  2331.             }

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

  2336.                 break;
  2337.             }

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

  2341.             break;
  2342.         }


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

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

  2349.             if (f->length) {

  2351.                 if (f->pos == f->last) {
  2352.                     break;
  2353.                 }

  2355.                 msg = f->pos;

  2357.                 if (f->pos + f->length <= f->last) {
  2358.                     f->pos += f->length;
  2359.                     f->length = 0;
  2360.                     f->state = ngx_http_fastcgi_st_padding;

  2362.                 } else {
  2363.                     f->length -= f->last - f->pos;
  2364.                     f->pos = f->last;
  2365.                 }

  2367.                 for (m = f->pos - 1; msg < m; m--) {
  2368.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2369.                         break;
  2370.                     }
  2371.                 }

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

  2377.             } else {
  2378.                 f->state = ngx_http_fastcgi_st_padding;
  2379.             }

  2381.             continue;
  2382.         }

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

  2386.             if (f->pos + f->length <= f->last) {
  2387.                 f->state = ngx_http_fastcgi_st_padding;
  2388.                 f->pos += f->length;

  2390.                 continue;
  2391.             }

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

  2395.             break;
  2396.         }


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

  2401.         if (f->pos == f->last) {
  2402.             break;
  2403.         }

  2405.         if (f->rest == -2) {
  2406.             f->rest = r->upstream->headers_in.content_length_n;
  2407.         }

  2409.         if (f->rest == 0) {
  2410.             ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2411.                           "upstream sent more data than specified in "
  2412.                           "\"Content-Length\" header");
  2413.             p->upstream_done = 1;
  2414.             break;
  2415.         }

  2417.         cl = ngx_chain_get_free_buf(p->pool, &p->free);
  2418.         if (cl == NULL) {
  2419.             return NGX_ERROR;
  2420.         }

  2422.         b = cl->buf;

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

  2426.         b->pos = f->pos;
  2427.         b->start = buf->start;
  2428.         b->end = buf->end;
  2429.         b->tag = p->tag;
  2430.         b->temporary = 1;
  2431.         b->recycled = 1;

  2433.         *prev = b;
  2434.         prev = &b->shadow;

  2436.         if (p->in) {
  2437.             *p->last_in = cl;
  2438.         } else {
  2439.             p->in = cl;
  2440.         }
  2441.         p->last_in = &cl->next;


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

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

  2449.         if (f->pos + f->length <= f->last) {
  2450.             f->state = ngx_http_fastcgi_st_padding;
  2451.             f->pos += f->length;
  2452.             b->last = f->pos;

  2454.         } else {
  2455.             f->length -= f->last - f->pos;
  2456.             f->pos = f->last;
  2457.             b->last = f->last;
  2458.         }

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

  2462.             if (b->last - b->pos > f->rest) {
  2463.                 ngx_log_error(NGX_LOG_WARN, p->log, 0,
  2464.                               "upstream sent more data than specified in "
  2465.                               "\"Content-Length\" header");

  2467.                 b->last = b->pos + f->rest;
  2468.                 p->upstream_done = 1;

  2470.                 break;
  2471.             }

  2473.             f->rest -= b->last - b->pos;
  2474.         }
  2475.     }

  2477.     if (flcf->keep_conn) {

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

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

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

  2487.         } else {
  2488.             /* ngx_http_fastcgi_st_data */

  2490.             p->length = f->length;
  2491.         }
  2492.     }

  2494.     if (b) {
  2495.         b->shadow = buf;
  2496.         b->last_shadow = 1;

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

  2501.         return NGX_OK;
  2502.     }

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

  2506.     if (ngx_event_pipe_add_free_buf(p, buf) != NGX_OK) {
  2507.         return NGX_ERROR;
  2508.     }

  2510.     return NGX_OK;
  2511. }


  2514. static ngx_int_t
  2515. ‌ngx_http_fastcgi_non_buffered_filter(void *data, ssize_t bytes)
  2516. {
  2517.     u_char                  *m, *msg;
  2518.     ngx_int_t                rc;
  2519.     ngx_buf_t               *b, *buf;
  2520.     ngx_chain_t             *cl, **ll;
  2521.     ngx_http_request_t      *r;
  2522.     ngx_http_upstream_t     *u;
  2523.     ngx_http_fastcgi_ctx_t  *f;

  2525.     r = data;
  2526.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  2528.     u = r->upstream;
  2529.     buf = &u->buffer;

  2531.     buf->pos = buf->last;
  2532.     buf->last += bytes;

  2534.     for (cl = u->out_bufs, ll = &u->out_bufs; cl; cl = cl->next) {
  2535.         ll = &cl->next;
  2536.     }

  2538.     f->pos = buf->pos;
  2539.     f->last = buf->last;

  2541.     for ( ;; ) {
  2542.         if (f->state < ngx_http_fastcgi_st_data) {

  2544.             rc = ngx_http_fastcgi_process_record(r, f);

  2546.             if (rc == NGX_AGAIN) {
  2547.                 break;
  2548.             }

  2550.             if (rc == NGX_ERROR) {
  2551.                 return NGX_ERROR;
  2552.             }

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

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

  2560.                 continue;
  2561.             }
  2562.         }

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

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

  2568.                 if (f->rest > 0) {
  2569.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2570.                                   "upstream prematurely closed "
  2571.                                   "FastCGI request");
  2572.                     u->error = 1;
  2573.                     break;
  2574.                 }

  2576.                 if (f->pos + f->padding < f->last) {
  2577.                     u->length = 0;
  2578.                     break;
  2579.                 }

  2581.                 if (f->pos + f->padding == f->last) {
  2582.                     u->length = 0;
  2583.                     u->keepalive = 1;
  2584.                     break;
  2585.                 }

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

  2589.                 break;
  2590.             }

  2592.             if (f->pos + f->padding < f->last) {
  2593.                 f->state = ngx_http_fastcgi_st_version;
  2594.                 f->pos += f->padding;

  2596.                 continue;
  2597.             }

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

  2602.                 break;
  2603.             }

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

  2607.             break;
  2608.         }


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

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

  2615.             if (f->length) {

  2617.                 if (f->pos == f->last) {
  2618.                     break;
  2619.                 }

  2621.                 msg = f->pos;

  2623.                 if (f->pos + f->length <= f->last) {
  2624.                     f->pos += f->length;
  2625.                     f->length = 0;
  2626.                     f->state = ngx_http_fastcgi_st_padding;

  2628.                 } else {
  2629.                     f->length -= f->last - f->pos;
  2630.                     f->pos = f->last;
  2631.                 }

  2633.                 for (m = f->pos - 1; msg < m; m--) {
  2634.                     if (*m != LF && *m != CR && *m != '.' && *m != ' ') {
  2635.                         break;
  2636.                     }
  2637.                 }

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

  2643.             } else {
  2644.                 f->state = ngx_http_fastcgi_st_padding;
  2645.             }

  2647.             continue;
  2648.         }

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

  2652.             if (f->pos + f->length <= f->last) {
  2653.                 f->state = ngx_http_fastcgi_st_padding;
  2654.                 f->pos += f->length;

  2656.                 continue;
  2657.             }

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

  2661.             break;
  2662.         }


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

  2667.         if (f->pos == f->last) {
  2668.             break;
  2669.         }

  2671.         if (f->rest == 0) {
  2672.             ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  2673.                           "upstream sent more data than specified in "
  2674.                           "\"Content-Length\" header");
  2675.             u->length = 0;
  2676.             break;
  2677.         }

  2679.         cl = ngx_chain_get_free_buf(r->pool, &u->free_bufs);
  2680.         if (cl == NULL) {
  2681.             return NGX_ERROR;
  2682.         }

  2684.         *ll = cl;
  2685.         ll = &cl->next;

  2687.         b = cl->buf;

  2689.         b->flush = 1;
  2690.         b->memory = 1;

  2692.         b->pos = f->pos;
  2693.         b->tag = u->output.tag;

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

  2698.         if (f->pos + f->length <= f->last) {
  2699.             f->state = ngx_http_fastcgi_st_padding;
  2700.             f->pos += f->length;
  2701.             b->last = f->pos;

  2703.         } else {
  2704.             f->length -= f->last - f->pos;
  2705.             f->pos = f->last;
  2706.             b->last = f->last;
  2707.         }

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

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

  2716.                 b->last = b->pos + f->rest;
  2717.                 u->length = 0;

  2719.                 break;
  2720.             }

  2722.             f->rest -= b->last - b->pos;
  2723.         }
  2724.     }

  2726.     return NGX_OK;
  2727. }


  2730. static ngx_int_t
  2731. ‌ngx_http_fastcgi_process_record(ngx_http_request_t *r,
  2732.     ngx_http_fastcgi_ctx_t *f)
  2733. {
  2734.     u_char                     ch, *p;
  2735.     ngx_http_fastcgi_state_e   state;

  2737.     state = f->state;

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

  2741.         ch = *p;

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

  2746.         switch (state) {

  2748.         case ngx_http_fastcgi_st_version:
  2749.             if (ch != 1) {
  2750.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2751.                               "upstream sent unsupported FastCGI "
  2752.                               "protocol version: %d", ch);
  2753.                 return NGX_ERROR;
  2754.             }
  2755.             state = ngx_http_fastcgi_st_type;
  2756.             break;

  2758.         case ngx_http_fastcgi_st_type:
  2759.             switch (ch) {
  2760.             case NGX_HTTP_FASTCGI_STDOUT:
  2761.             case NGX_HTTP_FASTCGI_STDERR:
  2762.             case NGX_HTTP_FASTCGI_END_REQUEST:
  2763.                 f->type = (ngx_uint_t) ch;
  2764.                 break;
  2765.             default:
  2766.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2767.                               "upstream sent invalid FastCGI "
  2768.                               "record type: %d", ch);
  2769.                 return NGX_ERROR;

  2771.             }
  2772.             state = ngx_http_fastcgi_st_request_id_hi;
  2773.             break;

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

  2777.         case ngx_http_fastcgi_st_request_id_hi:
  2778.             if (ch != 0) {
  2779.                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2780.                               "upstream sent unexpected FastCGI "
  2781.                               "request id high byte: %d", ch);
  2782.                 return NGX_ERROR;
  2783.             }
  2784.             state = ngx_http_fastcgi_st_request_id_lo;
  2785.             break;

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

  2797.         case ngx_http_fastcgi_st_content_length_hi:
  2798.             f->length = ch << 8;
  2799.             state = ngx_http_fastcgi_st_content_length_lo;
  2800.             break;

  2802.         case ngx_http_fastcgi_st_content_length_lo:
  2803.             f->length |= (size_t) ch;
  2804.             state = ngx_http_fastcgi_st_padding_length;
  2805.             break;

  2807.         case ngx_http_fastcgi_st_padding_length:
  2808.             f->padding = (size_t) ch;
  2809.             state = ngx_http_fastcgi_st_reserved;
  2810.             break;

  2812.         case ngx_http_fastcgi_st_reserved:
  2813.             state = ngx_http_fastcgi_st_data;

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

  2818.             f->pos = p + 1;
  2819.             f->state = state;

  2821.             return NGX_OK;

  2823.         /* suppress warning */
  2824.         case ngx_http_fastcgi_st_data:
  2825.         case ngx_http_fastcgi_st_padding:
  2826.             break;
  2827.         }
  2828.     }

  2830.     f->pos = p;
  2831.     f->state = state;

  2833.     return NGX_AGAIN;
  2834. }


  2837. static void
  2838. ‌ngx_http_fastcgi_abort_request(ngx_http_request_t *r)
  2839. {
  2840.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2841.                    "abort http fastcgi request");

  2843.     return;
  2844. }


  2847. static void
  2848. ‌ngx_http_fastcgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  2849. {
  2850.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2851.                    "finalize http fastcgi request");

  2853.     return;
  2854. }


  2857. static ngx_int_t
  2858. ‌ngx_http_fastcgi_add_variables(ngx_conf_t *cf)
  2859. {
  2860.     ngx_http_variable_t  *var, *v;

  2862.     for (v = ngx_http_fastcgi_vars; v->name.len; v++) {
  2863.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  2864.         if (var == NULL) {
  2865.             return NGX_ERROR;
  2866.         }

  2868.         var->get_handler = v->get_handler;
  2869.         var->data = v->data;
  2870.     }

  2872.     return NGX_OK;
  2873. }


  2876. static void *
  2877. ‌ngx_http_fastcgi_create_main_conf(ngx_conf_t *cf)
  2878. {
  2879.     ngx_http_fastcgi_main_conf_t  *conf;

  2881.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_main_conf_t));
  2882.     if (conf == NULL) {
  2883.         return NULL;
  2884.     }

  2886. #if (NGX_HTTP_CACHE)
  2887.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  2888.                        sizeof(ngx_http_file_cache_t *))
  2889.         != NGX_OK)
  2890.     {
  2891.         return NULL;
  2892.     }
  2893. #endif

  2895.     return conf;
  2896. }


  2899. static void *
  2900. ‌ngx_http_fastcgi_create_loc_conf(ngx_conf_t *cf)
  2901. {
  2902.     ngx_http_fastcgi_loc_conf_t  *conf;

  2904.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fastcgi_loc_conf_t));
  2905.     if (conf == NULL) {
  2906.         return NULL;
  2907.     }

  2909.     /*
  2910.      * set by ngx_pcalloc():
  2911.      *
  2912.      *     conf->upstream.bufs.num = 0;
  2913.      *     conf->upstream.ignore_headers = 0;
  2914.      *     conf->upstream.next_upstream = 0;
  2915.      *     conf->upstream.cache_zone = NULL;
  2916.      *     conf->upstream.cache_use_stale = 0;
  2917.      *     conf->upstream.cache_methods = 0;
  2918.      *     conf->upstream.temp_path = NULL;
  2919.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  2920.      *     conf->upstream.store_lengths = NULL;
  2921.      *     conf->upstream.store_values = NULL;
  2922.      *
  2923.      *     conf->index = { 0, NULL };
  2924.      */

  2926.     conf->upstream.store = NGX_CONF_UNSET;
  2927.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  2928.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  2929.     conf->upstream.buffering = NGX_CONF_UNSET;
  2930.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  2931.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  2932.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  2934.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  2935.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  2936.     conf->upstream.socket_rcvbuf = NGX_CONF_UNSET_SIZE;
  2937.     conf->upstream.socket_sndbuf = NGX_CONF_UNSET_SIZE;

  2939.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  2940.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  2941.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  2942.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  2944.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  2945.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  2946.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  2948.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  2949.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  2950.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  2952.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  2953.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  2955. #if (NGX_HTTP_CACHE)
  2956.     conf->upstream.cache = NGX_CONF_UNSET;
  2957.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  2958.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  2959.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  2960.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  2961.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  2962.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  2963.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  2964.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  2965.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  2966.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  2967. #endif

  2969.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  2970.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  2972.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  2974.     /* "fastcgi_cyclic_temp_file" is disabled */
  2975.     conf->upstream.cyclic_temp_file = 0;

  2977.     conf->upstream.change_buffering = 1;

  2979.     conf->catch_stderr = NGX_CONF_UNSET_PTR;

  2981.     conf->keep_conn = NGX_CONF_UNSET;

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

  2985.     return conf;
  2986. }


  2989. static char *
  2990. ‌ngx_http_fastcgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  2991. {
  2992.     ngx_http_fastcgi_loc_conf_t *prev = parent;
  2993.     ngx_http_fastcgi_loc_conf_t *conf = child;

  2995.     size_t                        size;
  2996.     ngx_int_t                     rc;
  2997.     ngx_hash_init_t               hash;
  2998.     ngx_http_core_loc_conf_t     *clcf;

  3000. #if (NGX_HTTP_CACHE)

  3002.     if (conf->upstream.store > 0) {
  3003.         conf->upstream.cache = 0;
  3004.     }

  3006.     if (conf->upstream.cache > 0) {
  3007.         conf->upstream.store = 0;
  3008.     }

  3010. #endif

  3012.     if (conf->upstream.store == NGX_CONF_UNSET) {
  3013.         ngx_conf_merge_value(conf->upstream.store,
  3014.                               prev->upstream.store, 0);

  3016.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  3017.         conf->upstream.store_values = prev->upstream.store_values;
  3018.     }

  3020.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  3021.                               prev->upstream.store_access, 0600);

  3023.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  3024.                               prev->upstream.next_upstream_tries, 0);

  3026.     ngx_conf_merge_value(conf->upstream.buffering,
  3027.                               prev->upstream.buffering, 1);

  3029.     ngx_conf_merge_value(conf->upstream.request_buffering,
  3030.                               prev->upstream.request_buffering, 1);

  3032.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  3033.                               prev->upstream.ignore_client_abort, 0);

  3035.     ngx_conf_merge_value(conf->upstream.force_ranges,
  3036.                               prev->upstream.force_ranges, 0);

  3038.     ngx_conf_merge_ptr_value(conf->upstream.local,
  3039.                               prev->upstream.local, NULL);

  3041.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  3042.                               prev->upstream.socket_keepalive, 0);

  3044.     ngx_conf_merge_size_value(conf->upstream.socket_rcvbuf,
  3045.                               prev->upstream.socket_rcvbuf, 0);

  3047.     ngx_conf_merge_size_value(conf->upstream.socket_sndbuf,
  3048.                               prev->upstream.socket_sndbuf, 0);

  3050.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  3051.                               prev->upstream.connect_timeout, 60000);

  3053.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  3054.                               prev->upstream.send_timeout, 60000);

  3056.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  3057.                               prev->upstream.read_timeout, 60000);

  3059.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  3060.                               prev->upstream.next_upstream_timeout, 0);

  3062.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  3063.                               prev->upstream.send_lowat, 0);

  3065.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  3066.                               prev->upstream.buffer_size,
  3067.                               (size_t) ngx_pagesize);

  3069.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  3070.                               prev->upstream.limit_rate, NULL);


  3073.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  3074.                               8, ngx_pagesize);

  3076.     if (conf->upstream.bufs.num < 2) {
  3077.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3078.                            "there must be at least 2 \"fastcgi_buffers\"");
  3079.         return NGX_CONF_ERROR;
  3080.     }


  3083.     size = conf->upstream.buffer_size;
  3084.     if (size < conf->upstream.bufs.size) {
  3085.         size = conf->upstream.bufs.size;
  3086.     }


  3089.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  3090.                               prev->upstream.busy_buffers_size_conf,
  3091.                               NGX_CONF_UNSET_SIZE);

  3093.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  3094.         conf->upstream.busy_buffers_size = 2 * size;
  3095.     } else {
  3096.         conf->upstream.busy_buffers_size =
  3097.                                          conf->upstream.busy_buffers_size_conf;
  3098.     }

  3100.     if (conf->upstream.busy_buffers_size < size) {
  3101.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3102.              "\"fastcgi_busy_buffers_size\" must be equal to or greater than "
  3103.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3104.              "one of the \"fastcgi_buffers\"");

  3106.         return NGX_CONF_ERROR;
  3107.     }

  3109.     if (conf->upstream.busy_buffers_size
  3110.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  3111.     {
  3112.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3113.              "\"fastcgi_busy_buffers_size\" must be less than "
  3114.              "the size of all \"fastcgi_buffers\" minus one buffer");

  3116.         return NGX_CONF_ERROR;
  3117.     }


  3120.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  3121.                               prev->upstream.temp_file_write_size_conf,
  3122.                               NGX_CONF_UNSET_SIZE);

  3124.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  3125.         conf->upstream.temp_file_write_size = 2 * size;
  3126.     } else {
  3127.         conf->upstream.temp_file_write_size =
  3128.                                       conf->upstream.temp_file_write_size_conf;
  3129.     }

  3131.     if (conf->upstream.temp_file_write_size < size) {
  3132.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3133.              "\"fastcgi_temp_file_write_size\" must be equal to or greater "
  3134.              "than the maximum of the value of \"fastcgi_buffer_size\" and "
  3135.              "one of the \"fastcgi_buffers\"");

  3137.         return NGX_CONF_ERROR;
  3138.     }


  3141.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  3142.                               prev->upstream.max_temp_file_size_conf,
  3143.                               NGX_CONF_UNSET_SIZE);

  3145.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  3146.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  3147.     } else {
  3148.         conf->upstream.max_temp_file_size =
  3149.                                         conf->upstream.max_temp_file_size_conf;
  3150.     }

  3152.     if (conf->upstream.max_temp_file_size != 0
  3153.         && conf->upstream.max_temp_file_size < size)
  3154.     {
  3155.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3156.              "\"fastcgi_max_temp_file_size\" must be equal to zero to disable "
  3157.              "temporary files usage or must be equal to or greater than "
  3158.              "the maximum of the value of \"fastcgi_buffer_size\" and "
  3159.              "one of the \"fastcgi_buffers\"");

  3161.         return NGX_CONF_ERROR;
  3162.     }


  3165.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  3166.                               prev->upstream.ignore_headers,
  3167.                               NGX_CONF_BITMASK_SET);


  3170.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  3171.                               prev->upstream.next_upstream,
  3172.                               (NGX_CONF_BITMASK_SET
  3173.                                |NGX_HTTP_UPSTREAM_FT_ERROR
  3174.                                |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  3176.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  3177.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  3178.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  3179.     }

  3181.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  3182.                               prev->upstream.temp_path,
  3183.                               &ngx_http_fastcgi_temp_path)
  3184.         != NGX_CONF_OK)
  3185.     {
  3186.         return NGX_CONF_ERROR;
  3187.     }

  3189. #if (NGX_HTTP_CACHE)

  3191.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  3192.         ngx_conf_merge_value(conf->upstream.cache,
  3193.                               prev->upstream.cache, 0);

  3195.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  3196.         conf->upstream.cache_value = prev->upstream.cache_value;
  3197.     }

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

  3202.         shm_zone = conf->upstream.cache_zone;

  3204.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3205.                            "\"fastcgi_cache\" zone \"%V\" is unknown",
  3206.                            &shm_zone->shm.name);

  3208.         return NGX_CONF_ERROR;
  3209.     }

  3211.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  3212.                               prev->upstream.cache_min_uses, 1);

  3214.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  3215.                               prev->upstream.cache_max_range_offset,
  3216.                               NGX_MAX_OFF_T_VALUE);

  3218.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  3219.                               prev->upstream.cache_use_stale,
  3220.                               (NGX_CONF_BITMASK_SET
  3221.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  3223.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  3224.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  3225.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  3226.     }

  3228.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  3229.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  3230.     }

  3232.     if (conf->upstream.cache_methods == 0) {
  3233.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  3234.     }

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

  3238.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  3239.                              prev->upstream.cache_bypass, NULL);

  3241.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  3242.                              prev->upstream.no_cache, NULL);

  3244.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  3245.                              prev->upstream.cache_valid, NULL);

  3247.     if (conf->cache_key.value.data == NULL) {
  3248.         conf->cache_key = prev->cache_key;
  3249.     }

  3251.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  3252.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  3253.                            "no \"fastcgi_cache_key\" for \"fastcgi_cache\"");
  3254.     }

  3256.     ngx_conf_merge_value(conf->upstream.cache_lock,
  3257.                               prev->upstream.cache_lock, 0);

  3259.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  3260.                               prev->upstream.cache_lock_timeout, 5000);

  3262.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  3263.                               prev->upstream.cache_lock_age, 5000);

  3265.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  3266.                               prev->upstream.cache_revalidate, 0);

  3268.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  3269.                               prev->upstream.cache_background_update, 0);

  3271. #endif

  3273.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  3274.                               prev->upstream.pass_request_headers, 1);
  3275.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  3276.                               prev->upstream.pass_request_body, 1);

  3278.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  3279.                               prev->upstream.intercept_errors, 0);

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

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


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

  3288.     hash.max_size = 512;
  3289.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  3290.     hash.name = "fastcgi_hide_headers_hash";

  3292.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  3293.              &prev->upstream, ngx_http_fastcgi_hide_headers, &hash)
  3294.         != NGX_OK)
  3295.     {
  3296.         return NGX_CONF_ERROR;
  3297.     }

  3299.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3301.     if (clcf->noname
  3302.         && conf->upstream.upstream == NULL && conf->fastcgi_lengths == NULL)
  3303.     {
  3304.         conf->upstream.upstream = prev->upstream.upstream;
  3305.         conf->fastcgi_lengths = prev->fastcgi_lengths;
  3306.         conf->fastcgi_values = prev->fastcgi_values;
  3307.     }

  3309.     if (clcf->lmt_excpt && clcf->handler == NULL
  3310.         && (conf->upstream.upstream || conf->fastcgi_lengths))
  3311.     {
  3312.         clcf->handler = ngx_http_fastcgi_handler;
  3313.     }

  3315. #if (NGX_PCRE)
  3316.     if (conf->split_regex == NULL) {
  3317.         conf->split_regex = prev->split_regex;
  3318.         conf->split_name = prev->split_name;
  3319.     }
  3320. #endif

  3322.     if (conf->params_source == NULL) {
  3323.         conf->params = prev->params;
  3324. #if (NGX_HTTP_CACHE)
  3325.         conf->params_cache = prev->params_cache;
  3326. #endif
  3327.         conf->params_source = prev->params_source;
  3328.     }

  3330.     rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params,
  3331.                                       ngx_http_fastcgi_headers);
  3332.     if (rc != NGX_OK) {
  3333.         return NGX_CONF_ERROR;
  3334.     }

  3336. #if (NGX_HTTP_CACHE)

  3338.     if (conf->upstream.cache) {
  3339.         rc = ngx_http_fastcgi_init_params(cf, conf, &conf->params_cache,
  3340.                                           ngx_http_fastcgi_cache_headers);
  3341.         if (rc != NGX_OK) {
  3342.             return NGX_CONF_ERROR;
  3343.         }
  3344.     }

  3346. #endif

  3348.     /*
  3349.      * special handling to preserve conf->params in the "http" section
  3350.      * to inherit it to all servers
  3351.      */

  3353.     if (prev->params.hash.buckets == NULL
  3354.         && conf->params_source == prev->params_source)
  3355.     {
  3356.         prev->params = conf->params;
  3357. #if (NGX_HTTP_CACHE)
  3358.         prev->params_cache = conf->params_cache;
  3359. #endif
  3360.     }

  3362.     return NGX_CONF_OK;
  3363. }


  3366. static ngx_int_t
  3367. ‌ngx_http_fastcgi_init_params(ngx_conf_t *cf, ngx_http_fastcgi_loc_conf_t *conf,
  3368.     ngx_http_fastcgi_params_t *params, ngx_keyval_t *default_params)
  3369. {
  3370.     u_char                       *p;
  3371.     size_t                        size;
  3372.     uintptr_t                    *code;
  3373.     ngx_uint_t                    i, nsrc;
  3374.     ngx_array_t                   headers_names, params_merged;
  3375.     ngx_keyval_t                 *h;
  3376.     ngx_hash_key_t               *hk;
  3377.     ngx_hash_init_t               hash;
  3378.     ngx_http_upstream_param_t    *src, *s;
  3379.     ngx_http_script_compile_t     sc;
  3380.     ngx_http_script_copy_code_t  *copy;

  3382.     if (params->hash.buckets) {
  3383.         return NGX_OK;
  3384.     }

  3386.     if (conf->params_source == NULL && default_params == NULL) {
  3387.         params->hash.buckets = (void *) 1;
  3388.         return NGX_OK;
  3389.     }

  3391.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  3392.     if (params->lengths == NULL) {
  3393.         return NGX_ERROR;
  3394.     }

  3396.     params->values = ngx_array_create(cf->pool, 512, 1);
  3397.     if (params->values == NULL) {
  3398.         return NGX_ERROR;
  3399.     }

  3401.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  3402.         != NGX_OK)
  3403.     {
  3404.         return NGX_ERROR;
  3405.     }

  3407.     if (conf->params_source) {
  3408.         src = conf->params_source->elts;
  3409.         nsrc = conf->params_source->nelts;

  3411.     } else {
  3412.         src = NULL;
  3413.         nsrc = 0;
  3414.     }

  3416.     if (default_params) {
  3417.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  3418.                            sizeof(ngx_http_upstream_param_t))
  3419.             != NGX_OK)
  3420.         {
  3421.             return NGX_ERROR;
  3422.         }

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

  3426.             s = ngx_array_push(&params_merged);
  3427.             if (s == NULL) {
  3428.                 return NGX_ERROR;
  3429.             }

  3431.             *s = src[i];
  3432.         }

  3434.         h = default_params;

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

  3438.             src = params_merged.elts;
  3439.             nsrc = params_merged.nelts;

  3441.             for (i = 0; i < nsrc; i++) {
  3442.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  3443.                     goto next;
  3444.                 }
  3445.             }

  3447.             s = ngx_array_push(&params_merged);
  3448.             if (s == NULL) {
  3449.                 return NGX_ERROR;
  3450.             }

  3452.             s->key = h->key;
  3453.             s->value = h->value;
  3454.             s->skip_empty = 1;

  3456.         next:

  3458.             h++;
  3459.         }

  3461.         src = params_merged.elts;
  3462.         nsrc = params_merged.nelts;
  3463.     }

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

  3467.         if (src[i].key.len > sizeof("HTTP_") - 1
  3468.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  3469.         {
  3470.             hk = ngx_array_push(&headers_names);
  3471.             if (hk == NULL) {
  3472.                 return NGX_ERROR;
  3473.             }

  3475.             hk->key.len = src[i].key.len - 5;
  3476.             hk->key.data = src[i].key.data + 5;
  3477.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  3478.             hk->value = (void *) 1;

  3480.             if (src[i].value.len == 0) {
  3481.                 continue;
  3482.             }
  3483.         }

  3485.         copy = ngx_array_push_n(params->lengths,
  3486.                                 sizeof(ngx_http_script_copy_code_t));
  3487.         if (copy == NULL) {
  3488.             return NGX_ERROR;
  3489.         }

  3491.         copy->code = (ngx_http_script_code_pt) (void *)
  3492.                                                  ngx_http_script_copy_len_code;
  3493.         copy->len = src[i].key.len;

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

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


  3506.         size = (sizeof(ngx_http_script_copy_code_t)
  3507.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  3508.                & ~(sizeof(uintptr_t) - 1);

  3510.         copy = ngx_array_push_n(params->values, size);
  3511.         if (copy == NULL) {
  3512.             return NGX_ERROR;
  3513.         }

  3515.         copy->code = ngx_http_script_copy_code;
  3516.         copy->len = src[i].key.len;

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


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

  3524.         sc.cf = cf;
  3525.         sc.source = &src[i].value;
  3526.         sc.flushes = &params->flushes;
  3527.         sc.lengths = &params->lengths;
  3528.         sc.values = &params->values;

  3530.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3531.             return NGX_ERROR;
  3532.         }

  3534.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3535.         if (code == NULL) {
  3536.             return NGX_ERROR;
  3537.         }

  3539.         *code = (uintptr_t) NULL;


  3542.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  3543.         if (code == NULL) {
  3544.             return NGX_ERROR;
  3545.         }

  3547.         *code = (uintptr_t) NULL;
  3548.     }

  3550.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  3551.     if (code == NULL) {
  3552.         return NGX_ERROR;
  3553.     }

  3555.     *code = (uintptr_t) NULL;

  3557.     params->number = headers_names.nelts;

  3559.     hash.hash = &params->hash;
  3560.     hash.key = ngx_hash_key_lc;
  3561.     hash.max_size = 512;
  3562.     hash.bucket_size = 64;
  3563.     hash.name = "fastcgi_params_hash";
  3564.     hash.pool = cf->pool;
  3565.     hash.temp_pool = NULL;

  3567.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  3568. }


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

  3579.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3581.     f = ngx_http_fastcgi_split(r, flcf);

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

  3587.     if (f->script_name.len == 0
  3588.         || f->script_name.data[f->script_name.len - 1] != '/')
  3589.     {
  3590.         v->len = f->script_name.len;
  3591.         v->valid = 1;
  3592.         v->no_cacheable = 0;
  3593.         v->not_found = 0;
  3594.         v->data = f->script_name.data;

  3596.         return NGX_OK;
  3597.     }

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

  3601.     v->data = ngx_pnalloc(r->pool, v->len);
  3602.     if (v->data == NULL) {
  3603.         return NGX_ERROR;
  3604.     }

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

  3609.     return NGX_OK;
  3610. }


  3613. static ngx_int_t
  3614. ‌ngx_http_fastcgi_path_info_variable(ngx_http_request_t *r,
  3615.     ngx_http_variable_value_t *v, uintptr_t data)
  3616. {
  3617.     ngx_http_fastcgi_ctx_t       *f;
  3618.     ngx_http_fastcgi_loc_conf_t  *flcf;

  3620.     flcf = ngx_http_get_module_loc_conf(r, ngx_http_fastcgi_module);

  3622.     f = ngx_http_fastcgi_split(r, flcf);

  3624.     if (f == NULL) {
  3625.         return NGX_ERROR;
  3626.     }

  3628.     v->len = f->path_info.len;
  3629.     v->valid = 1;
  3630.     v->no_cacheable = 0;
  3631.     v->not_found = 0;
  3632.     v->data = f->path_info.data;

  3634.     return NGX_OK;
  3635. }


  3638. static ngx_http_fastcgi_ctx_t *
  3639. ‌ngx_http_fastcgi_split(ngx_http_request_t *r, ngx_http_fastcgi_loc_conf_t *flcf)
  3640. {
  3641.     ngx_http_fastcgi_ctx_t       *f;
  3642. #if (NGX_PCRE)
  3643.     ngx_int_t                     n;
  3644.     int                           captures[(1 + 2) * 3];

  3646.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

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

  3654.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3655.     }

  3657.     if (f->script_name.len) {
  3658.         return f;
  3659.     }

  3661.     if (flcf->split_regex == NULL) {
  3662.         f->script_name = r->uri;
  3663.         return f;
  3664.     }

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

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

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

  3675.         return f;
  3676.     }

  3678.     if (n == NGX_REGEX_NO_MATCHED) {
  3679.         f->script_name = r->uri;
  3680.         return f;
  3681.     }

  3683.     ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  3684.                   ngx_regex_exec_n " failed: %i on \"%V\" using \"%V\"",
  3685.                   n, &r->uri, &flcf->split_name);
  3686.     return NULL;

  3688. #else

  3690.     f = ngx_http_get_module_ctx(r, ngx_http_fastcgi_module);

  3692.     if (f == NULL) {
  3693.         f = ngx_pcalloc(r->pool, sizeof(ngx_http_fastcgi_ctx_t));
  3694.         if (f == NULL) {
  3695.             return NULL;
  3696.         }

  3698.         ngx_http_set_ctx(r, f, ngx_http_fastcgi_module);
  3699.     }

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

  3703.     return f;

  3705. #endif
  3706. }


  3709. static char *
  3710. ‌ngx_http_fastcgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3711. {
  3712.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3714.     ngx_url_t                   u;
  3715.     ngx_str_t                  *value, *url;
  3716.     ngx_uint_t                  n;
  3717.     ngx_http_core_loc_conf_t   *clcf;
  3718.     ngx_http_script_compile_t   sc;

  3720.     if (flcf->upstream.upstream || flcf->fastcgi_lengths) {
  3721.         return "is duplicate";
  3722.     }

  3724.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  3726.     clcf->handler = ngx_http_fastcgi_handler;

  3728.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  3729.         clcf->auto_redirect = 1;
  3730.     }

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

  3734.     url = &value[1];

  3736.     n = ngx_http_script_variables_count(url);

  3738.     if (n) {

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

  3742.         sc.cf = cf;
  3743.         sc.source = url;
  3744.         sc.lengths = &flcf->fastcgi_lengths;
  3745.         sc.values = &flcf->fastcgi_values;
  3746.         sc.variables = n;
  3747.         sc.complete_lengths = 1;
  3748.         sc.complete_values = 1;

  3750.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  3751.             return NGX_CONF_ERROR;
  3752.         }

  3754.         return NGX_CONF_OK;
  3755.     }

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

  3759.     u.url = value[1];
  3760.     u.no_resolve = 1;

  3762.     flcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  3763.     if (flcf->upstream.upstream == NULL) {
  3764.         return NGX_CONF_ERROR;
  3765.     }

  3767.     return NGX_CONF_OK;
  3768. }


  3771. static char *
  3772. ‌ngx_http_fastcgi_split_path_info(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3773. {
  3774. #if (NGX_PCRE)
  3775.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3777.     ngx_str_t            *value;
  3778.     ngx_regex_compile_t   rc;
  3779.     u_char                errstr[NGX_MAX_CONF_ERRSTR];

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

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

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

  3787.     rc.pattern = value[1];
  3788.     rc.pool = cf->pool;
  3789.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  3790.     rc.err.data = errstr;

  3792.     if (ngx_regex_compile(&rc) != NGX_OK) {
  3793.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%V", &rc.err);
  3794.         return NGX_CONF_ERROR;
  3795.     }

  3797.     if (rc.captures != 2) {
  3798.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3799.                            "pattern \"%V\" must have 2 captures", &value[1]);
  3800.         return NGX_CONF_ERROR;
  3801.     }

  3803.     flcf->split_regex = rc.regex;

  3805.     return NGX_CONF_OK;

  3807. #else

  3809.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3810.                        "\"%V\" requires PCRE library", &cmd->name);
  3811.     return NGX_CONF_ERROR;

  3813. #endif
  3814. }


  3817. static char *
  3818. ‌ngx_http_fastcgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3819. {
  3820.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3822.     ngx_str_t                  *value;
  3823.     ngx_http_script_compile_t   sc;

  3825.     if (flcf->upstream.store != NGX_CONF_UNSET) {
  3826.         return "is duplicate";
  3827.     }

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

  3831.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3832.         flcf->upstream.store = 0;
  3833.         return NGX_CONF_OK;
  3834.     }

  3836.     if (value[1].len == 0) {
  3837.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  3838.         return NGX_CONF_ERROR;
  3839.     }

  3841. #if (NGX_HTTP_CACHE)
  3842.     if (flcf->upstream.cache > 0) {
  3843.         return "is incompatible with \"fastcgi_cache\"";
  3844.     }
  3845. #endif

  3847.     flcf->upstream.store = 1;

  3849.     if (ngx_strcmp(value[1].data, "on") == 0) {
  3850.         return NGX_CONF_OK;
  3851.     }

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

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

  3858.     sc.cf = cf;
  3859.     sc.source = &value[1];
  3860.     sc.lengths = &flcf->upstream.store_lengths;
  3861.     sc.values = &flcf->upstream.store_values;
  3862.     sc.variables = ngx_http_script_variables_count(&value[1]);
  3863.     sc.complete_lengths = 1;
  3864.     sc.complete_values = 1;

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

  3870.     return NGX_CONF_OK;
  3871. }


  3874. #if (NGX_HTTP_CACHE)

  3876. static char *
  3877. ‌ngx_http_fastcgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3878. {
  3879.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3881.     ngx_str_t                         *value;
  3882.     ngx_http_complex_value_t           cv;
  3883.     ngx_http_compile_complex_value_t   ccv;

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

  3887.     if (flcf->upstream.cache != NGX_CONF_UNSET) {
  3888.         return "is duplicate";
  3889.     }

  3891.     if (ngx_strcmp(value[1].data, "off") == 0) {
  3892.         flcf->upstream.cache = 0;
  3893.         return NGX_CONF_OK;
  3894.     }

  3896.     if (flcf->upstream.store > 0) {
  3897.         return "is incompatible with \"fastcgi_store\"";
  3898.     }

  3900.     flcf->upstream.cache = 1;

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

  3904.     ccv.cf = cf;
  3905.     ccv.value = &value[1];
  3906.     ccv.complex_value = &cv;

  3908.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3909.         return NGX_CONF_ERROR;
  3910.     }

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

  3914.         flcf->upstream.cache_value = ngx_palloc(cf->pool,
  3915.                                              sizeof(ngx_http_complex_value_t));
  3916.         if (flcf->upstream.cache_value == NULL) {
  3917.             return NGX_CONF_ERROR;
  3918.         }

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

  3922.         return NGX_CONF_OK;
  3923.     }

  3925.     flcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  3926.                                                       &ngx_http_fastcgi_module);
  3927.     if (flcf->upstream.cache_zone == NULL) {
  3928.         return NGX_CONF_ERROR;
  3929.     }

  3931.     return NGX_CONF_OK;
  3932. }


  3935. static char *
  3936. ‌ngx_http_fastcgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  3937. {
  3938.     ngx_http_fastcgi_loc_conf_t *flcf = conf;

  3940.     ngx_str_t                         *value;
  3941.     ngx_http_compile_complex_value_t   ccv;

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

  3945.     if (flcf->cache_key.value.data) {
  3946.         return "is duplicate";
  3947.     }

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

  3951.     ccv.cf = cf;
  3952.     ccv.value = &value[1];
  3953.     ccv.complex_value = &flcf->cache_key;

  3955.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  3956.         return NGX_CONF_ERROR;
  3957.     }

  3959.     return NGX_CONF_OK;
  3960. }

  3962. #endif


  3965. static char *
  3966. ‌ngx_http_fastcgi_lowat_check(ngx_conf_t *cf, void *post, void *data)
  3967. {
  3968. #if (NGX_FREEBSD)
  3969.     ssize_t *np = data;

  3971.     if ((u_long) *np >= ngx_freebsd_net_inet_tcp_sendspace) {
  3972.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  3973.                            "\"fastcgi_send_lowat\" must be less than %d "
  3974.                            "(sysctl net.inet.tcp.sendspace)",
  3975.                            ngx_freebsd_net_inet_tcp_sendspace);

  3977.         return NGX_CONF_ERROR;
  3978.     }

  3980. #elif !(NGX_HAVE_SO_SNDLOWAT)
  3981.     ssize_t *np = data;

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

  3986.     *np = 0;

  3988. #endif

  3990.     return NGX_CONF_OK;
  3991. }

One Level Up Top Level