One Level Up Top Level

src/http/modules/ngx_http_scgi_module.c - nginx-1.31.3 nginx/ @ 42f8df65b

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. * Copyright (C) Manlio Perillo (manlio.perillo@gmail.com)
  6. */


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


  14. ‌typedef struct {
  15.     ngx_array_t                caches;  /* ngx_http_file_cache_t * */
  16. ‌} ngx_http_scgi_main_conf_t;


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


  28. ‌typedef struct {
  29.     ngx_http_upstream_conf_t   upstream;

  31.     ngx_http_scgi_params_t     params;
  32. #if (NGX_HTTP_CACHE)
  33.     ngx_http_scgi_params_t     params_cache;
  34. #endif
  35.     ngx_array_t               *params_source;

  37.     ngx_array_t               *scgi_lengths;
  38.     ngx_array_t               *scgi_values;

  40. #if (NGX_HTTP_CACHE)
  41.     ngx_http_complex_value_t   cache_key;
  42. #endif
  43. ‌} ngx_http_scgi_loc_conf_t;


  46. static ngx_int_t ngx_http_scgi_eval(ngx_http_request_t *r,
  47.     ngx_http_scgi_loc_conf_t *scf);
  48. static ngx_int_t ngx_http_scgi_create_request(ngx_http_request_t *r);
  49. static ngx_int_t ngx_http_scgi_reinit_request(ngx_http_request_t *r);
  50. static ngx_int_t ngx_http_scgi_process_status_line(ngx_http_request_t *r);
  51. static ngx_int_t ngx_http_scgi_process_header(ngx_http_request_t *r);
  52. static ngx_int_t ngx_http_scgi_input_filter_init(void *data);
  53. static void ngx_http_scgi_abort_request(ngx_http_request_t *r);
  54. static void ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc);

  56. static void *ngx_http_scgi_create_main_conf(ngx_conf_t *cf);
  57. static void *ngx_http_scgi_create_loc_conf(ngx_conf_t *cf);
  58. static char *ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent,
  59.     void *child);
  60. static ngx_int_t ngx_http_scgi_init_params(ngx_conf_t *cf,
  61.     ngx_http_scgi_loc_conf_t *conf, ngx_http_scgi_params_t *params,
  62.     ngx_keyval_t *default_params);

  64. static char *ngx_http_scgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  65. static char *ngx_http_scgi_store(ngx_conf_t *cf, ngx_command_t *cmd,
  66.     void *conf);

  68. #if (NGX_HTTP_CACHE)
  69. static ngx_int_t ngx_http_scgi_create_key(ngx_http_request_t *r);
  70. static char *ngx_http_scgi_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  71.     void *conf);
  72. static char *ngx_http_scgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd,
  73.     void *conf);
  74. #endif


  77. ‌static ngx_conf_bitmask_t ngx_http_scgi_next_upstream_masks[] = {
  78.     { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
  79.     { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
  80.     { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
  81.     { ngx_string("non_idempotent"), NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT },
  82.     { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  83.     { ngx_string("http_503"), NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  84.     { ngx_string("http_403"), NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  85.     { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  86.     { ngx_string("http_429"), NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  87.     { ngx_string("updating"), NGX_HTTP_UPSTREAM_FT_UPDATING },
  88.     { ngx_string("off"), NGX_HTTP_UPSTREAM_FT_OFF },
  89.     { ngx_null_string, 0 }
  90. };


  93. ‌ngx_module_t  ngx_http_scgi_module;


  96. ‌static ngx_command_t ngx_http_scgi_commands[] = {

  98.     { ngx_string("scgi_pass"),
  99.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  100.       ngx_http_scgi_pass,
  101.       NGX_HTTP_LOC_CONF_OFFSET,
  102.       0,
  103.       NULL },

  105.     { ngx_string("scgi_store"),
  106.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  107.       ngx_http_scgi_store,
  108.       NGX_HTTP_LOC_CONF_OFFSET,
  109.       0,
  110.       NULL },

  112.     { ngx_string("scgi_store_access"),
  113.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  114.       ngx_conf_set_access_slot,
  115.       NGX_HTTP_LOC_CONF_OFFSET,
  116.       offsetof(ngx_http_scgi_loc_conf_t, upstream.store_access),
  117.       NULL },

  119.     { ngx_string("scgi_buffering"),
  120.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  121.       ngx_conf_set_flag_slot,
  122.       NGX_HTTP_LOC_CONF_OFFSET,
  123.       offsetof(ngx_http_scgi_loc_conf_t, upstream.buffering),
  124.       NULL },

  126.     { ngx_string("scgi_request_buffering"),
  127.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  128.       ngx_conf_set_flag_slot,
  129.       NGX_HTTP_LOC_CONF_OFFSET,
  130.       offsetof(ngx_http_scgi_loc_conf_t, upstream.request_buffering),
  131.       NULL },

  133.     { ngx_string("scgi_ignore_client_abort"),
  134.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  135.       ngx_conf_set_flag_slot,
  136.       NGX_HTTP_LOC_CONF_OFFSET,
  137.       offsetof(ngx_http_scgi_loc_conf_t, upstream.ignore_client_abort),
  138.       NULL },

  140.     { ngx_string("scgi_bind"),
  141.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  142.       ngx_http_upstream_bind_set_slot,
  143.       NGX_HTTP_LOC_CONF_OFFSET,
  144.       offsetof(ngx_http_scgi_loc_conf_t, upstream.local),
  145.       NULL },

  147.     { ngx_string("scgi_socket_keepalive"),
  148.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  149.       ngx_conf_set_flag_slot,
  150.       NGX_HTTP_LOC_CONF_OFFSET,
  151.       offsetof(ngx_http_scgi_loc_conf_t, upstream.socket_keepalive),
  152.       NULL },

  154.     { ngx_string("scgi_connect_timeout"),
  155.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  156.       ngx_conf_set_msec_slot,
  157.       NGX_HTTP_LOC_CONF_OFFSET,
  158.       offsetof(ngx_http_scgi_loc_conf_t, upstream.connect_timeout),
  159.       NULL },

  161.     { ngx_string("scgi_send_timeout"),
  162.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  163.       ngx_conf_set_msec_slot,
  164.       NGX_HTTP_LOC_CONF_OFFSET,
  165.       offsetof(ngx_http_scgi_loc_conf_t, upstream.send_timeout),
  166.       NULL },

  168.     { ngx_string("scgi_buffer_size"),
  169.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  170.       ngx_conf_set_size_slot,
  171.       NGX_HTTP_LOC_CONF_OFFSET,
  172.       offsetof(ngx_http_scgi_loc_conf_t, upstream.buffer_size),
  173.       NULL },

  175.     { ngx_string("scgi_pass_request_headers"),
  176.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  177.       ngx_conf_set_flag_slot,
  178.       NGX_HTTP_LOC_CONF_OFFSET,
  179.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_request_headers),
  180.       NULL },

  182.     { ngx_string("scgi_pass_request_body"),
  183.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  184.       ngx_conf_set_flag_slot,
  185.       NGX_HTTP_LOC_CONF_OFFSET,
  186.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_request_body),
  187.       NULL },

  189.     { ngx_string("scgi_intercept_errors"),
  190.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  191.       ngx_conf_set_flag_slot,
  192.       NGX_HTTP_LOC_CONF_OFFSET,
  193.       offsetof(ngx_http_scgi_loc_conf_t, upstream.intercept_errors),
  194.       NULL },

  196.     { ngx_string("scgi_read_timeout"),
  197.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  198.       ngx_conf_set_msec_slot,
  199.       NGX_HTTP_LOC_CONF_OFFSET,
  200.       offsetof(ngx_http_scgi_loc_conf_t, upstream.read_timeout),
  201.       NULL },

  203.     { ngx_string("scgi_buffers"),
  204.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  205.       ngx_conf_set_bufs_slot,
  206.       NGX_HTTP_LOC_CONF_OFFSET,
  207.       offsetof(ngx_http_scgi_loc_conf_t, upstream.bufs),
  208.       NULL },

  210.     { ngx_string("scgi_busy_buffers_size"),
  211.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  212.       ngx_conf_set_size_slot,
  213.       NGX_HTTP_LOC_CONF_OFFSET,
  214.       offsetof(ngx_http_scgi_loc_conf_t, upstream.busy_buffers_size_conf),
  215.       NULL },

  217.     { ngx_string("scgi_force_ranges"),
  218.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  219.       ngx_conf_set_flag_slot,
  220.       NGX_HTTP_LOC_CONF_OFFSET,
  221.       offsetof(ngx_http_scgi_loc_conf_t, upstream.force_ranges),
  222.       NULL },

  224.     { ngx_string("scgi_limit_rate"),
  225.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  226.       ngx_http_set_complex_value_size_slot,
  227.       NGX_HTTP_LOC_CONF_OFFSET,
  228.       offsetof(ngx_http_scgi_loc_conf_t, upstream.limit_rate),
  229.       NULL },

  231. #if (NGX_HTTP_CACHE)

  233.     { ngx_string("scgi_cache"),
  234.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  235.       ngx_http_scgi_cache,
  236.       NGX_HTTP_LOC_CONF_OFFSET,
  237.       0,
  238.       NULL },

  240.     { ngx_string("scgi_cache_key"),
  241.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  242.       ngx_http_scgi_cache_key,
  243.       NGX_HTTP_LOC_CONF_OFFSET,
  244.       0,
  245.       NULL },

  247.     { ngx_string("scgi_cache_path"),
  248.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  249.       ngx_http_file_cache_set_slot,
  250.       NGX_HTTP_MAIN_CONF_OFFSET,
  251.       offsetof(ngx_http_scgi_main_conf_t, caches),
  252.       &ngx_http_scgi_module },

  254.     { ngx_string("scgi_cache_bypass"),
  255.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  256.       ngx_http_set_predicate_slot,
  257.       NGX_HTTP_LOC_CONF_OFFSET,
  258.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_bypass),
  259.       NULL },

  261.     { ngx_string("scgi_no_cache"),
  262.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  263.       ngx_http_set_predicate_slot,
  264.       NGX_HTTP_LOC_CONF_OFFSET,
  265.       offsetof(ngx_http_scgi_loc_conf_t, upstream.no_cache),
  266.       NULL },

  268.     { ngx_string("scgi_cache_valid"),
  269.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  270.       ngx_http_file_cache_valid_set_slot,
  271.       NGX_HTTP_LOC_CONF_OFFSET,
  272.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_valid),
  273.       NULL },

  275.     { ngx_string("scgi_cache_min_uses"),
  276.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  277.       ngx_conf_set_num_slot,
  278.       NGX_HTTP_LOC_CONF_OFFSET,
  279.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_min_uses),
  280.       NULL },

  282.     { ngx_string("scgi_cache_max_range_offset"),
  283.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  284.       ngx_conf_set_off_slot,
  285.       NGX_HTTP_LOC_CONF_OFFSET,
  286.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_max_range_offset),
  287.       NULL },

  289.     { ngx_string("scgi_cache_use_stale"),
  290.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  291.       ngx_conf_set_bitmask_slot,
  292.       NGX_HTTP_LOC_CONF_OFFSET,
  293.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_use_stale),
  294.       &ngx_http_scgi_next_upstream_masks },

  296.     { ngx_string("scgi_cache_methods"),
  297.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  298.       ngx_conf_set_bitmask_slot,
  299.       NGX_HTTP_LOC_CONF_OFFSET,
  300.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_methods),
  301.       &ngx_http_upstream_cache_method_mask },

  303.     { ngx_string("scgi_cache_lock"),
  304.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  305.       ngx_conf_set_flag_slot,
  306.       NGX_HTTP_LOC_CONF_OFFSET,
  307.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock),
  308.       NULL },

  310.     { ngx_string("scgi_cache_lock_timeout"),
  311.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  312.       ngx_conf_set_msec_slot,
  313.       NGX_HTTP_LOC_CONF_OFFSET,
  314.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock_timeout),
  315.       NULL },

  317.     { ngx_string("scgi_cache_lock_age"),
  318.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  319.       ngx_conf_set_msec_slot,
  320.       NGX_HTTP_LOC_CONF_OFFSET,
  321.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock_age),
  322.       NULL },

  324.     { ngx_string("scgi_cache_revalidate"),
  325.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  326.       ngx_conf_set_flag_slot,
  327.       NGX_HTTP_LOC_CONF_OFFSET,
  328.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_revalidate),
  329.       NULL },

  331.     { ngx_string("scgi_cache_background_update"),
  332.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  333.       ngx_conf_set_flag_slot,
  334.       NGX_HTTP_LOC_CONF_OFFSET,
  335.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_background_update),
  336.       NULL },

  338. #endif

  340.     { ngx_string("scgi_temp_path"),
  341.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  342.       ngx_conf_set_path_slot,
  343.       NGX_HTTP_LOC_CONF_OFFSET,
  344.       offsetof(ngx_http_scgi_loc_conf_t, upstream.temp_path),
  345.       NULL },

  347.     { ngx_string("scgi_max_temp_file_size"),
  348.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  349.       ngx_conf_set_size_slot,
  350.       NGX_HTTP_LOC_CONF_OFFSET,
  351.       offsetof(ngx_http_scgi_loc_conf_t, upstream.max_temp_file_size_conf),
  352.       NULL },

  354.     { ngx_string("scgi_temp_file_write_size"),
  355.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  356.       ngx_conf_set_size_slot,
  357.       NGX_HTTP_LOC_CONF_OFFSET,
  358.       offsetof(ngx_http_scgi_loc_conf_t, upstream.temp_file_write_size_conf),
  359.       NULL },

  361.     { ngx_string("scgi_next_upstream"),
  362.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  363.       ngx_conf_set_bitmask_slot,
  364.       NGX_HTTP_LOC_CONF_OFFSET,
  365.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream),
  366.       &ngx_http_scgi_next_upstream_masks },

  368.     { ngx_string("scgi_next_upstream_tries"),
  369.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  370.       ngx_conf_set_num_slot,
  371.       NGX_HTTP_LOC_CONF_OFFSET,
  372.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream_tries),
  373.       NULL },

  375.     { ngx_string("scgi_next_upstream_timeout"),
  376.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  377.       ngx_conf_set_msec_slot,
  378.       NGX_HTTP_LOC_CONF_OFFSET,
  379.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream_timeout),
  380.       NULL },

  382.     { ngx_string("scgi_param"),
  383.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  384.       ngx_http_upstream_param_set_slot,
  385.       NGX_HTTP_LOC_CONF_OFFSET,
  386.       offsetof(ngx_http_scgi_loc_conf_t, params_source),
  387.       NULL },

  389.     { ngx_string("scgi_pass_header"),
  390.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  391.       ngx_conf_set_str_array_slot,
  392.       NGX_HTTP_LOC_CONF_OFFSET,
  393.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_headers),
  394.       NULL },

  396.     { ngx_string("scgi_hide_header"),
  397.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  398.       ngx_conf_set_str_array_slot,
  399.       NGX_HTTP_LOC_CONF_OFFSET,
  400.       offsetof(ngx_http_scgi_loc_conf_t, upstream.hide_headers),
  401.       NULL },

  403.     { ngx_string("scgi_ignore_headers"),
  404.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  405.       ngx_conf_set_bitmask_slot,
  406.       NGX_HTTP_LOC_CONF_OFFSET,
  407.       offsetof(ngx_http_scgi_loc_conf_t, upstream.ignore_headers),
  408.       &ngx_http_upstream_ignore_headers_masks },

  410.       ngx_null_command
  411. };


  414. ‌static ngx_http_module_t ngx_http_scgi_module_ctx = {
  415.     NULL,                                  /* preconfiguration */
  416.     NULL,                                  /* postconfiguration */

  418.     ngx_http_scgi_create_main_conf,        /* create main configuration */
  419.     NULL,                                  /* init main configuration */

  421.     NULL,                                  /* create server configuration */
  422.     NULL,                                  /* merge server configuration */

  424.     ngx_http_scgi_create_loc_conf,         /* create location configuration */
  425.     ngx_http_scgi_merge_loc_conf           /* merge location configuration */
  426. };


  429. ‌ngx_module_t ngx_http_scgi_module = {
  430.     NGX_MODULE_V1,
  431.     &ngx_http_scgi_module_ctx,             /* module context */
  432.     ngx_http_scgi_commands,                /* module directives */
  433.     NGX_HTTP_MODULE,                       /* module type */
  434.     NULL,                                  /* init master */
  435.     NULL,                                  /* init module */
  436.     NULL,                                  /* init process */
  437.     NULL,                                  /* init thread */
  438.     NULL,                                  /* exit thread */
  439.     NULL,                                  /* exit process */
  440.     NULL,                                  /* exit master */
  441.     NGX_MODULE_V1_PADDING
  442. };


  445. ‌static ngx_str_t ngx_http_scgi_hide_headers[] = {
  446.     ngx_string("Status"),
  447.     ngx_string("X-Accel-Expires"),
  448.     ngx_string("X-Accel-Redirect"),
  449.     ngx_string("X-Accel-Limit-Rate"),
  450.     ngx_string("X-Accel-Buffering"),
  451.     ngx_string("X-Accel-Charset"),
  452.     ngx_null_string
  453. };


  456. ‌static ngx_keyval_t  ngx_http_scgi_headers[] = {
  457.     { ngx_string("HTTP_HOST"),
  458.       ngx_string("$host$is_request_port$request_port") },
  459.     { ngx_null_string, ngx_null_string }
  460. };


  463. #if (NGX_HTTP_CACHE)

  465. ‌static ngx_keyval_t  ngx_http_scgi_cache_headers[] = {
  466.     { ngx_string("HTTP_HOST"),
  467.       ngx_string("$host$is_request_port$request_port") },
  468.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  469.       ngx_string("$upstream_cache_last_modified") },
  470.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  471.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  472.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  473.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  474.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  475.     { ngx_null_string, ngx_null_string }
  476. };

  478. #endif


  481. ‌static ngx_path_init_t ngx_http_scgi_temp_path = {
  482.     ngx_string(NGX_HTTP_SCGI_TEMP_PATH), { 1, 2, 0 }
  483. };


  486. static ngx_int_t
  487. ‌ngx_http_scgi_handler(ngx_http_request_t *r)
  488. {
  489.     ngx_int_t                   rc;
  490.     ngx_http_status_t          *status;
  491.     ngx_http_upstream_t        *u;
  492.     ngx_http_scgi_loc_conf_t   *scf;
  493. #if (NGX_HTTP_CACHE)
  494.     ngx_http_scgi_main_conf_t  *smcf;
  495. #endif

  497.     if (ngx_http_upstream_create(r) != NGX_OK) {
  498.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  499.     }

  501.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  502.     if (status == NULL) {
  503.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  504.     }

  506.     ngx_http_set_ctx(r, status, ngx_http_scgi_module);

  508.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  510.     if (scf->scgi_lengths) {
  511.         if (ngx_http_scgi_eval(r, scf) != NGX_OK) {
  512.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  513.         }
  514.     }

  516.     u = r->upstream;

  518.     ngx_str_set(&u->schema, "scgi://");
  519.     u->output.tag = (ngx_buf_tag_t) &ngx_http_scgi_module;

  521.     u->conf = &scf->upstream;

  523. #if (NGX_HTTP_CACHE)
  524.     smcf = ngx_http_get_module_main_conf(r, ngx_http_scgi_module);

  526.     u->caches = &smcf->caches;
  527.     u->create_key = ngx_http_scgi_create_key;
  528. #endif

  530.     u->create_request = ngx_http_scgi_create_request;
  531.     u->reinit_request = ngx_http_scgi_reinit_request;
  532.     u->process_header = ngx_http_scgi_process_status_line;
  533.     u->abort_request = ngx_http_scgi_abort_request;
  534.     u->finalize_request = ngx_http_scgi_finalize_request;
  535.     r->state = 0;

  537.     u->buffering = scf->upstream.buffering;

  539.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  540.     if (u->pipe == NULL) {
  541.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  542.     }

  544.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  545.     u->pipe->input_ctx = r;

  547.     u->input_filter_init = ngx_http_scgi_input_filter_init;
  548.     u->input_filter = ngx_http_upstream_non_buffered_filter;
  549.     u->input_filter_ctx = r;

  551.     if (!scf->upstream.request_buffering
  552.         && scf->upstream.pass_request_body
  553.         && !r->headers_in.chunked)
  554.     {
  555.         r->request_body_no_buffering = 1;
  556.     }

  558.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  560.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  561.         return rc;
  562.     }

  564.     return NGX_DONE;
  565. }


  568. static ngx_int_t
  569. ‌ngx_http_scgi_eval(ngx_http_request_t *r, ngx_http_scgi_loc_conf_t * scf)
  570. {
  571.     ngx_url_t             url;
  572.     ngx_http_upstream_t  *u;

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

  576.     if (ngx_http_script_run(r, &url.url, scf->scgi_lengths->elts, 0,
  577.                             scf->scgi_values->elts)
  578.         == NULL)
  579.     {
  580.         return NGX_ERROR;
  581.     }

  583.     url.no_resolve = 1;

  585.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  586.         if (url.err) {
  587.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  588.                           "%s in upstream \"%V\"", url.err, &url.url);
  589.         }

  591.         return NGX_ERROR;
  592.     }

  594.     u = r->upstream;

  596.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  597.     if (u->resolved == NULL) {
  598.         return NGX_ERROR;
  599.     }

  601.     if (url.addrs) {
  602.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  603.         u->resolved->socklen = url.addrs[0].socklen;
  604.         u->resolved->name = url.addrs[0].name;
  605.         u->resolved->naddrs = 1;
  606.     }

  608.     u->resolved->host = url.host;
  609.     u->resolved->port = url.port;
  610.     u->resolved->no_port = url.no_port;

  612.     return NGX_OK;
  613. }


  616. #if (NGX_HTTP_CACHE)

  618. static ngx_int_t
  619. ‌ngx_http_scgi_create_key(ngx_http_request_t *r)
  620. {
  621.     ngx_str_t                 *key;
  622.     ngx_http_scgi_loc_conf_t  *scf;

  624.     key = ngx_array_push(&r->cache->keys);
  625.     if (key == NULL) {
  626.         return NGX_ERROR;
  627.     }

  629.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  631.     if (ngx_http_complex_value(r, &scf->cache_key, key) != NGX_OK) {
  632.         return NGX_ERROR;
  633.     }

  635.     return NGX_OK;
  636. }

  638. #endif


  641. static ngx_int_t
  642. ‌ngx_http_scgi_create_request(ngx_http_request_t *r)
  643. {
  644.     off_t                         content_length_n;
  645.     u_char                        ch, sep, *key, *val, *lowcase_key;
  646.     size_t                        len, key_len, val_len, allocated;
  647.     ngx_buf_t                    *b;
  648.     ngx_str_t                     content_length;
  649.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  650.     ngx_chain_t                  *cl, *body;
  651.     ngx_list_part_t              *part;
  652.     ngx_table_elt_t              *header, *hn, **ignored;
  653.     ngx_http_scgi_params_t       *params;
  654.     ngx_http_script_code_pt       code;
  655.     ngx_http_script_engine_t      e, le;
  656.     ngx_http_scgi_loc_conf_t     *scf;
  657.     ngx_http_script_len_code_pt   lcode;
  658.     u_char                        buffer[NGX_OFF_T_LEN];

  660.     content_length_n = 0;

  662.     if (r->headers_in.content_length_n > 0) {
  663.         content_length_n = r->headers_in.content_length_n;
  664.     }

  666.     content_length.data = buffer;
  667.     content_length.len = ngx_sprintf(buffer, "%O", content_length_n) - buffer;

  669.     len = sizeof("CONTENT_LENGTH") + content_length.len + 1;

  671.     header_params = 0;
  672.     ignored = NULL;

  674.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  676. #if (NGX_HTTP_CACHE)
  677.     params = r->upstream->cacheable ? &scf->params_cache : &scf->params;
  678. #else
  679.     params = &scf->params;
  680. #endif

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

  685.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  686.         le.flushed = 1;

  688.         le.ip = params->lengths->elts;
  689.         le.request = r;

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

  693.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  694.             key_len = lcode(&le);

  696.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  697.             skip_empty = lcode(&le);

  699.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  700.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  701.             }
  702.             le.ip += sizeof(uintptr_t);

  704.             if (skip_empty && val_len == 0) {
  705.                 continue;
  706.             }

  708.             len += key_len + val_len + 1;
  709.         }
  710.     }

  712.     if (scf->upstream.pass_request_headers) {

  714.         allocated = 0;
  715.         lowcase_key = NULL;

  717.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  718.             return NGX_ERROR;
  719.         }

  721.         if (params->number || r->headers_in.multi) {
  722.             n = 0;
  723.             part = &r->headers_in.headers.part;

  725.             while (part) {
  726.                 n += part->nelts;
  727.                 part = part->next;
  728.             }

  730.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  731.             if (ignored == NULL) {
  732.                 return NGX_ERROR;
  733.             }
  734.         }

  736.         part = &r->headers_in.headers.part;
  737.         header = part->elts;

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

  741.             if (i >= part->nelts) {
  742.                 if (part->next == NULL) {
  743.                     break;
  744.                 }

  746.                 part = part->next;
  747.                 header = part->elts;
  748.                 i = 0;
  749.             }

  751.             for (n = 0; n < header_params; n++) {
  752.                 if (&header[i] == ignored[n]) {
  753.                     goto next_length;
  754.                 }
  755.             }

  757.             if (params->number) {
  758.                 if (allocated < header[i].key.len) {
  759.                     allocated = header[i].key.len + 16;
  760.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  761.                     if (lowcase_key == NULL) {
  762.                         return NGX_ERROR;
  763.                     }
  764.                 }

  766.                 hash = 0;

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

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

  774.                     } else if (ch == '-') {
  775.                         ch = '_';
  776.                     }

  778.                     hash = ngx_hash(hash, ch);
  779.                     lowcase_key[n] = ch;
  780.                 }

  782.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  783.                     ignored[header_params++] = &header[i];
  784.                     continue;
  785.                 }
  786.             }

  788.             len += sizeof("HTTP_") - 1 + header[i].key.len + 1
  789.                 + header[i].value.len + 1;

  791.             for (hn = header[i].next; hn; hn = hn->next) {
  792.                 len += hn->value.len + 2;
  793.                 ignored[header_params++] = hn;
  794.             }

  796.         next_length:

  798.             continue;
  799.         }
  800.     }

  802.     /* netstring: "length:" + packet + "," */

  804.     b = ngx_create_temp_buf(r->pool, NGX_SIZE_T_LEN + 1 + len + 1);
  805.     if (b == NULL) {
  806.         return NGX_ERROR;
  807.     }

  809.     cl = ngx_alloc_chain_link(r->pool);
  810.     if (cl == NULL) {
  811.         return NGX_ERROR;
  812.     }

  814.     cl->buf = b;

  816.     b->last = ngx_sprintf(b->last, "%ui:CONTENT_LENGTH%Z%V%Z",
  817.                           len, &content_length);

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

  822.         e.ip = params->values->elts;
  823.         e.pos = b->last;
  824.         e.request = r;
  825.         e.flushed = 1;

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

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

  831.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  832.             lcode(&le); /* key length */

  834.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  835.             skip_empty = lcode(&le);

  837.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  838.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  839.             }
  840.             le.ip += sizeof(uintptr_t);

  842.             if (skip_empty && val_len == 0) {
  843.                 e.skip = 1;

  845.                 while (*(uintptr_t *) e.ip) {
  846.                     code = *(ngx_http_script_code_pt *) e.ip;
  847.                     code((ngx_http_script_engine_t *) &e);
  848.                 }
  849.                 e.ip += sizeof(uintptr_t);

  851.                 e.skip = 0;

  853.                 continue;
  854.             }

  856. #if (NGX_DEBUG)
  857.             key = e.pos;
  858. #endif
  859.             code = *(ngx_http_script_code_pt *) e.ip;
  860.             code((ngx_http_script_engine_t *) &e);

  862. #if (NGX_DEBUG)
  863.             val = e.pos;
  864. #endif
  865.             while (*(uintptr_t *) e.ip) {
  866.                 code = *(ngx_http_script_code_pt *) e.ip;
  867.                 code((ngx_http_script_engine_t *) &e);
  868.             }
  869.             *e.pos++ = '\0';
  870.             e.ip += sizeof(uintptr_t);

  872.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  873.                            "scgi param: \"%s: %s\"", key, val);
  874.         }

  876.         b->last = e.pos;
  877.     }

  879.     if (scf->upstream.pass_request_headers) {

  881.         part = &r->headers_in.headers.part;
  882.         header = part->elts;

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

  886.             if (i >= part->nelts) {
  887.                 if (part->next == NULL) {
  888.                     break;
  889.                 }

  891.                 part = part->next;
  892.                 header = part->elts;
  893.                 i = 0;
  894.             }

  896.             for (n = 0; n < header_params; n++) {
  897.                 if (&header[i] == ignored[n]) {
  898.                     goto next_value;
  899.                 }
  900.             }

  902.             key = b->last;
  903.             b->last = ngx_cpymem(key, "HTTP_", sizeof("HTTP_") - 1);

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

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

  911.                 } else if (ch == '-') {
  912.                     ch = '_';
  913.                 }

  915.                 *b->last++ = ch;
  916.             }

  918.             *b->last++ = (u_char) 0;

  920.             val = b->last;
  921.             b->last = ngx_copy(val, header[i].value.data, header[i].value.len);

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

  925.                 if (header[i].key.len == sizeof("Cookie") - 1
  926.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  927.                                        sizeof("Cookie") - 1)
  928.                        == 0)
  929.                 {
  930.                     sep = ';';

  932.                 } else {
  933.                     sep = ',';
  934.                 }

  936.                 for (hn = header[i].next; hn; hn = hn->next) {
  937.                     *b->last++ = sep;
  938.                     *b->last++ = ' ';
  939.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  940.                 }
  941.             }

  943.             *b->last++ = (u_char) 0;

  945.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  946.                            "scgi param: \"%s: %s\"", key, val);

  948.         next_value:

  950.             continue;
  951.         }
  952.     }

  954.     *b->last++ = (u_char) ',';

  956.     if (r->request_body_no_buffering) {
  957.         r->upstream->request_bufs = cl;

  959.     } else if (scf->upstream.pass_request_body) {
  960.         body = r->upstream->request_bufs;
  961.         r->upstream->request_bufs = cl;

  963.         while (body) {
  964.             b = ngx_alloc_buf(r->pool);
  965.             if (b == NULL) {
  966.                 return NGX_ERROR;
  967.             }

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

  971.             cl->next = ngx_alloc_chain_link(r->pool);
  972.             if (cl->next == NULL) {
  973.                 return NGX_ERROR;
  974.             }

  976.             cl = cl->next;
  977.             cl->buf = b;

  979.             body = body->next;
  980.         }

  982.     } else {
  983.         r->upstream->request_bufs = cl;
  984.     }

  986.     cl->next = NULL;

  988.     return NGX_OK;
  989. }


  992. static ngx_int_t
  993. ‌ngx_http_scgi_reinit_request(ngx_http_request_t *r)
  994. {
  995.     ngx_http_status_t  *status;

  997.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  999.     if (status == NULL) {
  1000.         return NGX_OK;
  1001.     }

  1003.     status->code = 0;
  1004.     status->count = 0;
  1005.     status->start = NULL;
  1006.     status->end = NULL;

  1008.     r->upstream->process_header = ngx_http_scgi_process_status_line;
  1009.     r->state = 0;

  1011.     return NGX_OK;
  1012. }


  1015. static ngx_int_t
  1016. ‌ngx_http_scgi_process_status_line(ngx_http_request_t *r)
  1017. {
  1018.     size_t                len;
  1019.     ngx_int_t             rc;
  1020.     ngx_http_status_t    *status;
  1021.     ngx_http_upstream_t  *u;

  1023.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  1025.     if (status == NULL) {
  1026.         return NGX_ERROR;
  1027.     }

  1029.     u = r->upstream;

  1031.     rc = ngx_http_parse_status_line(r, &u->buffer, status);

  1033.     if (rc == NGX_AGAIN) {
  1034.         return rc;
  1035.     }

  1037.     if (rc == NGX_ERROR) {
  1038.         u->process_header = ngx_http_scgi_process_header;
  1039.         u->buffer.pos = status->line_start;
  1040.         r->state = 0;
  1041.         return ngx_http_scgi_process_header(r);
  1042.     }

  1044.     if (u->state && u->state->status == 0) {
  1045.         u->state->status = status->code;
  1046.     }

  1048.     u->headers_in.status_n = status->code;

  1050.     len = status->end - status->start;
  1051.     u->headers_in.status_line.len = len;

  1053.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1054.     if (u->headers_in.status_line.data == NULL) {
  1055.         return NGX_ERROR;
  1056.     }

  1058.     ngx_memcpy(u->headers_in.status_line.data, status->start, len);

  1060.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1061.                    "http scgi status %ui \"%V\"",
  1062.                    u->headers_in.status_n, &u->headers_in.status_line);

  1064.     u->process_header = ngx_http_scgi_process_header;

  1066.     return ngx_http_scgi_process_header(r);
  1067. }


  1070. static ngx_int_t
  1071. ‌ngx_http_scgi_process_header(ngx_http_request_t *r)
  1072. {
  1073.     ngx_str_t                      *status_line;
  1074.     ngx_int_t                       rc, status;
  1075.     ngx_table_elt_t                *h;
  1076.     ngx_http_upstream_t            *u;
  1077.     ngx_http_upstream_header_t     *hh;
  1078.     ngx_http_upstream_main_conf_t  *umcf;

  1080.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1082.     for ( ;; ) {

  1084.         rc = ngx_http_parse_header_line(r, &r->upstream->buffer, 1);

  1086.         if (rc == NGX_OK) {

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

  1090.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1091.             if (h == NULL) {
  1092.                 return NGX_ERROR;
  1093.             }

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

  1097.             h->key.len = r->header_name_end - r->header_name_start;
  1098.             h->value.len = r->header_end - r->header_start;

  1100.             h->key.data = ngx_pnalloc(r->pool,
  1101.                                       h->key.len + 1 + h->value.len + 1
  1102.                                       + h->key.len);
  1103.             if (h->key.data == NULL) {
  1104.                 h->hash = 0;
  1105.                 return NGX_ERROR;
  1106.             }

  1108.             h->value.data = h->key.data + h->key.len + 1;
  1109.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1111.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1112.             h->key.data[h->key.len] = '\0';
  1113.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1114.             h->value.data[h->value.len] = '\0';

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

  1119.             } else {
  1120.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1121.             }

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

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

  1129.                 if (rc != NGX_OK) {
  1130.                     return rc;
  1131.                 }
  1132.             }

  1134.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1135.                            "http scgi header: \"%V: %V\"", &h->key, &h->value);

  1137.             continue;
  1138.         }

  1140.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

  1144.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1145.                            "http scgi header done");

  1147.             u = r->upstream;

  1149.             if (u->headers_in.status_n) {
  1150.                 goto done;
  1151.             }

  1153.             if (u->headers_in.status) {
  1154.                 status_line = &u->headers_in.status->value;

  1156.                 status = ngx_atoi(status_line->data, 3);
  1157.                 if (status == NGX_ERROR) {
  1158.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1159.                                   "upstream sent invalid status \"%V\"",
  1160.                                   status_line);
  1161.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1162.                 }

  1164.                 u->headers_in.status_n = status;

  1166.                 if (status_line->len > 3) {
  1167.                     u->headers_in.status_line = *status_line;
  1168.                 }

  1170.             } else if (u->headers_in.location) {
  1171.                 u->headers_in.status_n = 302;
  1172.                 ngx_str_set(&u->headers_in.status_line,
  1173.                             "302 Moved Temporarily");

  1175.             } else {
  1176.                 u->headers_in.status_n = 200;
  1177.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1178.             }

  1180.             if (u->state && u->state->status == 0) {
  1181.                 u->state->status = u->headers_in.status_n;
  1182.             }

  1184.         done:

  1186.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1187.                 && r->headers_in.upgrade)
  1188.             {
  1189.                 u->upgrade = 1;
  1190.             }

  1192.             return NGX_OK;
  1193.         }

  1195.         if (rc == NGX_AGAIN) {
  1196.             return NGX_AGAIN;
  1197.         }

  1199.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1201.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1202.                       "upstream sent invalid header: \"%*s\\x%02xd...\"",
  1203.                       r->header_end - r->header_name_start,
  1204.                       r->header_name_start, *r->header_end);

  1206.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1207.     }
  1208. }


  1211. static ngx_int_t
  1212. ‌ngx_http_scgi_input_filter_init(void *data)
  1213. {
  1214.     ngx_http_request_t   *r = data;
  1215.     ngx_http_upstream_t  *u;

  1217.     u = r->upstream;

  1219.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1220.                    "http scgi filter init s:%ui l:%O",
  1221.                    u->headers_in.status_n, u->headers_in.content_length_n);

  1223.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1224.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  1225.     {
  1226.         u->pipe->length = 0;
  1227.         u->length = 0;

  1229.     } else if (r->method == NGX_HTTP_HEAD) {
  1230.         u->pipe->length = -1;
  1231.         u->length = -1;

  1233.     } else {
  1234.         u->pipe->length = u->headers_in.content_length_n;
  1235.         u->length = u->headers_in.content_length_n;
  1236.     }

  1238.     return NGX_OK;
  1239. }


  1242. static void
  1243. ‌ngx_http_scgi_abort_request(ngx_http_request_t *r)
  1244. {
  1245.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1246.                    "abort http scgi request");

  1248.     return;
  1249. }


  1252. static void
  1253. ‌ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1254. {
  1255.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1256.                    "finalize http scgi request");

  1258.     return;
  1259. }


  1262. static void *
  1263. ‌ngx_http_scgi_create_main_conf(ngx_conf_t *cf)
  1264. {
  1265.     ngx_http_scgi_main_conf_t  *conf;

  1267.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_main_conf_t));
  1268.     if (conf == NULL) {
  1269.         return NULL;
  1270.     }

  1272. #if (NGX_HTTP_CACHE)
  1273.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1274.                        sizeof(ngx_http_file_cache_t *))
  1275.         != NGX_OK)
  1276.     {
  1277.         return NULL;
  1278.     }
  1279. #endif

  1281.     return conf;
  1282. }


  1285. static void *
  1286. ‌ngx_http_scgi_create_loc_conf(ngx_conf_t *cf)
  1287. {
  1288.     ngx_http_scgi_loc_conf_t  *conf;

  1290.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_loc_conf_t));
  1291.     if (conf == NULL) {
  1292.         return NULL;
  1293.     }

  1295.     /*
  1296.      * set by ngx_pcalloc():
  1297.      *
  1298.      *     conf->upstream.bufs.num = 0;
  1299.      *     conf->upstream.ignore_headers = 0;
  1300.      *     conf->upstream.next_upstream = 0;
  1301.      *     conf->upstream.cache_zone = NULL;
  1302.      *     conf->upstream.cache_use_stale = 0;
  1303.      *     conf->upstream.cache_methods = 0;
  1304.      *     conf->upstream.temp_path = NULL;
  1305.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  1306.      *     conf->upstream.store_lengths = NULL;
  1307.      *     conf->upstream.store_values = NULL;
  1308.      */

  1310.     conf->upstream.store = NGX_CONF_UNSET;
  1311.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1312.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1313.     conf->upstream.buffering = NGX_CONF_UNSET;
  1314.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  1315.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1316.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1318.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  1319.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;

  1321.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1322.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1323.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1324.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1326.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1327.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1328.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  1330.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1331.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1332.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1334.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1335.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1337. #if (NGX_HTTP_CACHE)
  1338.     conf->upstream.cache = NGX_CONF_UNSET;
  1339.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1340.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  1341.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1342.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1343.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1344.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1345.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1346.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1347.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1348.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  1349. #endif

  1351.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1352.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1354.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1356.     /* "scgi_cyclic_temp_file" is disabled */
  1357.     conf->upstream.cyclic_temp_file = 0;

  1359.     conf->upstream.change_buffering = 1;

  1361.     ngx_str_set(&conf->upstream.module, "scgi");

  1363.     return conf;
  1364. }


  1367. static char *
  1368. ‌ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1369. {
  1370.     ngx_http_scgi_loc_conf_t *prev = parent;
  1371.     ngx_http_scgi_loc_conf_t *conf = child;

  1373.     size_t                        size;
  1374.     ngx_int_t                     rc;
  1375.     ngx_hash_init_t               hash;
  1376.     ngx_http_core_loc_conf_t     *clcf;

  1378. #if (NGX_HTTP_CACHE)

  1380.     if (conf->upstream.store > 0) {
  1381.         conf->upstream.cache = 0;
  1382.     }

  1384.     if (conf->upstream.cache > 0) {
  1385.         conf->upstream.store = 0;
  1386.     }

  1388. #endif

  1390.     if (conf->upstream.store == NGX_CONF_UNSET) {
  1391.         ngx_conf_merge_value(conf->upstream.store, prev->upstream.store, 0);

  1393.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1394.         conf->upstream.store_values = prev->upstream.store_values;
  1395.     }

  1397.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1398.                               prev->upstream.store_access, 0600);

  1400.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1401.                               prev->upstream.next_upstream_tries, 0);

  1403.     ngx_conf_merge_value(conf->upstream.buffering,
  1404.                               prev->upstream.buffering, 1);

  1406.     ngx_conf_merge_value(conf->upstream.request_buffering,
  1407.                               prev->upstream.request_buffering, 1);

  1409.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1410.                               prev->upstream.ignore_client_abort, 0);

  1412.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1413.                               prev->upstream.force_ranges, 0);

  1415.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1416.                               prev->upstream.local, NULL);

  1418.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  1419.                               prev->upstream.socket_keepalive, 0);

  1421.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1422.                               prev->upstream.connect_timeout, 60000);

  1424.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1425.                               prev->upstream.send_timeout, 60000);

  1427.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1428.                               prev->upstream.read_timeout, 60000);

  1430.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1431.                               prev->upstream.next_upstream_timeout, 0);

  1433.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1434.                               prev->upstream.send_lowat, 0);

  1436.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1437.                               prev->upstream.buffer_size,
  1438.                               (size_t) ngx_pagesize);

  1440.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  1441.                               prev->upstream.limit_rate, NULL);


  1444.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1445.                               8, ngx_pagesize);

  1447.     if (conf->upstream.bufs.num < 2) {
  1448.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1449.                            "there must be at least 2 \"scgi_buffers\"");
  1450.         return NGX_CONF_ERROR;
  1451.     }


  1454.     size = conf->upstream.buffer_size;
  1455.     if (size < conf->upstream.bufs.size) {
  1456.         size = conf->upstream.bufs.size;
  1457.     }


  1460.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1461.                               prev->upstream.busy_buffers_size_conf,
  1462.                               NGX_CONF_UNSET_SIZE);

  1464.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1465.         conf->upstream.busy_buffers_size = 2 * size;
  1466.     } else {
  1467.         conf->upstream.busy_buffers_size =
  1468.             conf->upstream.busy_buffers_size_conf;
  1469.     }

  1471.     if (conf->upstream.busy_buffers_size < size) {
  1472.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1473.             "\"scgi_busy_buffers_size\" must be equal to or greater "
  1474.             "than the maximum of the value of \"scgi_buffer_size\" and "
  1475.             "one of the \"scgi_buffers\"");

  1477.         return NGX_CONF_ERROR;
  1478.     }

  1480.     if (conf->upstream.busy_buffers_size
  1481.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1482.     {
  1483.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1484.             "\"scgi_busy_buffers_size\" must be less than "
  1485.             "the size of all \"scgi_buffers\" minus one buffer");

  1487.         return NGX_CONF_ERROR;
  1488.     }


  1491.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1492.                               prev->upstream.temp_file_write_size_conf,
  1493.                               NGX_CONF_UNSET_SIZE);

  1495.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1496.         conf->upstream.temp_file_write_size = 2 * size;
  1497.     } else {
  1498.         conf->upstream.temp_file_write_size =
  1499.             conf->upstream.temp_file_write_size_conf;
  1500.     }

  1502.     if (conf->upstream.temp_file_write_size < size) {
  1503.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1504.             "\"scgi_temp_file_write_size\" must be equal to or greater than "
  1505.             "the maximum of the value of \"scgi_buffer_size\" and "
  1506.             "one of the \"scgi_buffers\"");

  1508.         return NGX_CONF_ERROR;
  1509.     }


  1512.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1513.                               prev->upstream.max_temp_file_size_conf,
  1514.                               NGX_CONF_UNSET_SIZE);

  1516.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1517.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1518.     } else {
  1519.         conf->upstream.max_temp_file_size =
  1520.             conf->upstream.max_temp_file_size_conf;
  1521.     }

  1523.     if (conf->upstream.max_temp_file_size != 0
  1524.         && conf->upstream.max_temp_file_size < size)
  1525.     {
  1526.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1527.             "\"scgi_max_temp_file_size\" must be equal to zero to disable "
  1528.             "temporary files usage or must be equal to or greater than "
  1529.             "the maximum of the value of \"scgi_buffer_size\" and "
  1530.             "one of the \"scgi_buffers\"");

  1532.         return NGX_CONF_ERROR;
  1533.     }


  1536.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1537.                                  prev->upstream.ignore_headers,
  1538.                                  NGX_CONF_BITMASK_SET);


  1541.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1542.                                  prev->upstream.next_upstream,
  1543.                                  (NGX_CONF_BITMASK_SET
  1544.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1545.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1547.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1548.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1549.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1550.     }

  1552.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1553.                                   prev->upstream.temp_path,
  1554.                                   &ngx_http_scgi_temp_path)
  1555.         != NGX_CONF_OK)
  1556.     {
  1557.         return NGX_CONF_ERROR;
  1558.     }

  1560. #if (NGX_HTTP_CACHE)

  1562.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1563.         ngx_conf_merge_value(conf->upstream.cache,
  1564.                               prev->upstream.cache, 0);

  1566.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1567.         conf->upstream.cache_value = prev->upstream.cache_value;
  1568.     }

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

  1573.         shm_zone = conf->upstream.cache_zone;

  1575.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1576.                            "\"scgi_cache\" zone \"%V\" is unknown",
  1577.                            &shm_zone->shm.name);

  1579.         return NGX_CONF_ERROR;
  1580.     }

  1582.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1583.                               prev->upstream.cache_min_uses, 1);

  1585.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  1586.                               prev->upstream.cache_max_range_offset,
  1587.                               NGX_MAX_OFF_T_VALUE);

  1589.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1590.                               prev->upstream.cache_use_stale,
  1591.                               (NGX_CONF_BITMASK_SET
  1592.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1594.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1595.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1596.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1597.     }

  1599.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1600.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1601.     }

  1603.     if (conf->upstream.cache_methods == 0) {
  1604.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1605.     }

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

  1609.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1610.                              prev->upstream.cache_bypass, NULL);

  1612.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1613.                              prev->upstream.no_cache, NULL);

  1615.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1616.                              prev->upstream.cache_valid, NULL);

  1618.     if (conf->cache_key.value.data == NULL) {
  1619.         conf->cache_key = prev->cache_key;
  1620.     }

  1622.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1623.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1624.                            "no \"scgi_cache_key\" for \"scgi_cache\"");
  1625.     }

  1627.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1628.                               prev->upstream.cache_lock, 0);

  1630.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1631.                               prev->upstream.cache_lock_timeout, 5000);

  1633.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1634.                               prev->upstream.cache_lock_age, 5000);

  1636.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1637.                               prev->upstream.cache_revalidate, 0);

  1639.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  1640.                               prev->upstream.cache_background_update, 0);

  1642. #endif

  1644.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1645.                          prev->upstream.pass_request_headers, 1);
  1646.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1647.                          prev->upstream.pass_request_body, 1);

  1649.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1650.                          prev->upstream.intercept_errors, 0);

  1652.     hash.max_size = 512;
  1653.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1654.     hash.name = "scgi_hide_headers_hash";

  1656.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1657.             &prev->upstream, ngx_http_scgi_hide_headers, &hash)
  1658.         != NGX_OK)
  1659.     {
  1660.         return NGX_CONF_ERROR;
  1661.     }

  1663.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1665.     if (clcf->noname
  1666.         && conf->upstream.upstream == NULL && conf->scgi_lengths == NULL)
  1667.     {
  1668.         conf->upstream.upstream = prev->upstream.upstream;
  1669.         conf->scgi_lengths = prev->scgi_lengths;
  1670.         conf->scgi_values = prev->scgi_values;
  1671.     }

  1673.     if (clcf->lmt_excpt && clcf->handler == NULL
  1674.         && (conf->upstream.upstream || conf->scgi_lengths))
  1675.     {
  1676.         clcf->handler = ngx_http_scgi_handler;
  1677.     }

  1679.     if (conf->params_source == NULL) {
  1680.         conf->params = prev->params;
  1681. #if (NGX_HTTP_CACHE)
  1682.         conf->params_cache = prev->params_cache;
  1683. #endif
  1684.         conf->params_source = prev->params_source;
  1685.     }

  1687.     rc = ngx_http_scgi_init_params(cf, conf, &conf->params,
  1688.                                    ngx_http_scgi_headers);
  1689.     if (rc != NGX_OK) {
  1690.         return NGX_CONF_ERROR;
  1691.     }

  1693. #if (NGX_HTTP_CACHE)

  1695.     if (conf->upstream.cache) {
  1696.         rc = ngx_http_scgi_init_params(cf, conf, &conf->params_cache,
  1697.                                        ngx_http_scgi_cache_headers);
  1698.         if (rc != NGX_OK) {
  1699.             return NGX_CONF_ERROR;
  1700.         }
  1701.     }

  1703. #endif

  1705.     /*
  1706.      * special handling to preserve conf->params in the "http" section
  1707.      * to inherit it to all servers
  1708.      */

  1710.     if (prev->params.hash.buckets == NULL
  1711.         && conf->params_source == prev->params_source)
  1712.     {
  1713.         prev->params = conf->params;
  1714. #if (NGX_HTTP_CACHE)
  1715.         prev->params_cache = conf->params_cache;
  1716. #endif
  1717.     }

  1719.     return NGX_CONF_OK;
  1720. }


  1723. static ngx_int_t
  1724. ‌ngx_http_scgi_init_params(ngx_conf_t *cf, ngx_http_scgi_loc_conf_t *conf,
  1725.     ngx_http_scgi_params_t *params, ngx_keyval_t *default_params)
  1726. {
  1727.     u_char                       *p;
  1728.     size_t                        size;
  1729.     uintptr_t                    *code;
  1730.     ngx_uint_t                    i, nsrc;
  1731.     ngx_array_t                   headers_names, params_merged;
  1732.     ngx_keyval_t                 *h;
  1733.     ngx_hash_key_t               *hk;
  1734.     ngx_hash_init_t               hash;
  1735.     ngx_http_upstream_param_t    *src, *s;
  1736.     ngx_http_script_compile_t     sc;
  1737.     ngx_http_script_copy_code_t  *copy;

  1739.     if (params->hash.buckets) {
  1740.         return NGX_OK;
  1741.     }

  1743.     if (conf->params_source == NULL && default_params == NULL) {
  1744.         params->hash.buckets = (void *) 1;
  1745.         return NGX_OK;
  1746.     }

  1748.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  1749.     if (params->lengths == NULL) {
  1750.         return NGX_ERROR;
  1751.     }

  1753.     params->values = ngx_array_create(cf->pool, 512, 1);
  1754.     if (params->values == NULL) {
  1755.         return NGX_ERROR;
  1756.     }

  1758.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  1759.         != NGX_OK)
  1760.     {
  1761.         return NGX_ERROR;
  1762.     }

  1764.     if (conf->params_source) {
  1765.         src = conf->params_source->elts;
  1766.         nsrc = conf->params_source->nelts;

  1768.     } else {
  1769.         src = NULL;
  1770.         nsrc = 0;
  1771.     }

  1773.     if (default_params) {
  1774.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  1775.                            sizeof(ngx_http_upstream_param_t))
  1776.             != NGX_OK)
  1777.         {
  1778.             return NGX_ERROR;
  1779.         }

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

  1783.             s = ngx_array_push(&params_merged);
  1784.             if (s == NULL) {
  1785.                 return NGX_ERROR;
  1786.             }

  1788.             *s = src[i];
  1789.         }

  1791.         h = default_params;

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

  1795.             src = params_merged.elts;
  1796.             nsrc = params_merged.nelts;

  1798.             for (i = 0; i < nsrc; i++) {
  1799.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  1800.                     goto next;
  1801.                 }
  1802.             }

  1804.             s = ngx_array_push(&params_merged);
  1805.             if (s == NULL) {
  1806.                 return NGX_ERROR;
  1807.             }

  1809.             s->key = h->key;
  1810.             s->value = h->value;
  1811.             s->skip_empty = 1;

  1813.         next:

  1815.             h++;
  1816.         }

  1818.         src = params_merged.elts;
  1819.         nsrc = params_merged.nelts;
  1820.     }

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

  1824.         if (src[i].key.len > sizeof("HTTP_") - 1
  1825.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  1826.         {
  1827.             hk = ngx_array_push(&headers_names);
  1828.             if (hk == NULL) {
  1829.                 return NGX_ERROR;
  1830.             }

  1832.             hk->key.len = src[i].key.len - 5;
  1833.             hk->key.data = src[i].key.data + 5;
  1834.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  1835.             hk->value = (void *) 1;

  1837.             if (src[i].value.len == 0) {
  1838.                 continue;
  1839.             }
  1840.         }

  1842.         copy = ngx_array_push_n(params->lengths,
  1843.                                 sizeof(ngx_http_script_copy_code_t));
  1844.         if (copy == NULL) {
  1845.             return NGX_ERROR;
  1846.         }

  1848.         copy->code = (ngx_http_script_code_pt) (void *)
  1849.                                                  ngx_http_script_copy_len_code;
  1850.         copy->len = src[i].key.len + 1;

  1852.         copy = ngx_array_push_n(params->lengths,
  1853.                                 sizeof(ngx_http_script_copy_code_t));
  1854.         if (copy == NULL) {
  1855.             return NGX_ERROR;
  1856.         }

  1858.         copy->code = (ngx_http_script_code_pt) (void *)
  1859.                                                  ngx_http_script_copy_len_code;
  1860.         copy->len = src[i].skip_empty;


  1863.         size = (sizeof(ngx_http_script_copy_code_t)
  1864.                 + src[i].key.len + 1 + sizeof(uintptr_t) - 1)
  1865.                & ~(sizeof(uintptr_t) - 1);

  1867.         copy = ngx_array_push_n(params->values, size);
  1868.         if (copy == NULL) {
  1869.             return NGX_ERROR;
  1870.         }

  1872.         copy->code = ngx_http_script_copy_code;
  1873.         copy->len = src[i].key.len + 1;

  1875.         p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
  1876.         (void) ngx_cpystrn(p, src[i].key.data, src[i].key.len + 1);


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

  1881.         sc.cf = cf;
  1882.         sc.source = &src[i].value;
  1883.         sc.flushes = &params->flushes;
  1884.         sc.lengths = &params->lengths;
  1885.         sc.values = &params->values;

  1887.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1888.             return NGX_ERROR;
  1889.         }

  1891.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1892.         if (code == NULL) {
  1893.             return NGX_ERROR;
  1894.         }

  1896.         *code = (uintptr_t) NULL;


  1899.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  1900.         if (code == NULL) {
  1901.             return NGX_ERROR;
  1902.         }

  1904.         *code = (uintptr_t) NULL;
  1905.     }

  1907.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1908.     if (code == NULL) {
  1909.         return NGX_ERROR;
  1910.     }

  1912.     *code = (uintptr_t) NULL;

  1914.     params->number = headers_names.nelts;

  1916.     hash.hash = &params->hash;
  1917.     hash.key = ngx_hash_key_lc;
  1918.     hash.max_size = 512;
  1919.     hash.bucket_size = 64;
  1920.     hash.name = "scgi_params_hash";
  1921.     hash.pool = cf->pool;
  1922.     hash.temp_pool = NULL;

  1924.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  1925. }


  1928. static char *
  1929. ‌ngx_http_scgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1930. {
  1931.     ngx_http_scgi_loc_conf_t *scf = conf;

  1933.     ngx_url_t                   u;
  1934.     ngx_str_t                  *value, *url;
  1935.     ngx_uint_t                  n;
  1936.     ngx_http_core_loc_conf_t   *clcf;
  1937.     ngx_http_script_compile_t   sc;

  1939.     if (scf->upstream.upstream || scf->scgi_lengths) {
  1940.         return "is duplicate";
  1941.     }

  1943.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  1944.     clcf->handler = ngx_http_scgi_handler;

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

  1948.     url = &value[1];

  1950.     n = ngx_http_script_variables_count(url);

  1952.     if (n) {

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

  1956.         sc.cf = cf;
  1957.         sc.source = url;
  1958.         sc.lengths = &scf->scgi_lengths;
  1959.         sc.values = &scf->scgi_values;
  1960.         sc.variables = n;
  1961.         sc.complete_lengths = 1;
  1962.         sc.complete_values = 1;

  1964.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1965.             return NGX_CONF_ERROR;
  1966.         }

  1968.         return NGX_CONF_OK;
  1969.     }

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

  1973.     u.url = value[1];
  1974.     u.no_resolve = 1;

  1976.     scf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  1977.     if (scf->upstream.upstream == NULL) {
  1978.         return NGX_CONF_ERROR;
  1979.     }

  1981.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  1982.         clcf->auto_redirect = 1;
  1983.     }

  1985.     return NGX_CONF_OK;
  1986. }


  1989. static char *
  1990. ‌ngx_http_scgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1991. {
  1992.     ngx_http_scgi_loc_conf_t *scf = conf;

  1994.     ngx_str_t                  *value;
  1995.     ngx_http_script_compile_t   sc;

  1997.     if (scf->upstream.store != NGX_CONF_UNSET) {
  1998.         return "is duplicate";
  1999.     }

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

  2003.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2004.         scf->upstream.store = 0;
  2005.         return NGX_CONF_OK;
  2006.     }

  2008.     if (value[1].len == 0) {
  2009.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  2010.         return NGX_CONF_ERROR;
  2011.     }

  2013. #if (NGX_HTTP_CACHE)
  2014.     if (scf->upstream.cache > 0) {
  2015.         return "is incompatible with \"scgi_cache\"";
  2016.     }
  2017. #endif

  2019.     scf->upstream.store = 1;

  2021.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2022.         return NGX_CONF_OK;
  2023.     }

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

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

  2030.     sc.cf = cf;
  2031.     sc.source = &value[1];
  2032.     sc.lengths = &scf->upstream.store_lengths;
  2033.     sc.values = &scf->upstream.store_values;
  2034.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2035.     sc.complete_lengths = 1;
  2036.     sc.complete_values = 1;

  2038.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2039.         return NGX_CONF_ERROR;
  2040.     }

  2042.     return NGX_CONF_OK;
  2043. }


  2046. #if (NGX_HTTP_CACHE)

  2048. static char *
  2049. ‌ngx_http_scgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2050. {
  2051.     ngx_http_scgi_loc_conf_t *scf = conf;

  2053.     ngx_str_t                         *value;
  2054.     ngx_http_complex_value_t           cv;
  2055.     ngx_http_compile_complex_value_t   ccv;

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

  2059.     if (scf->upstream.cache != NGX_CONF_UNSET) {
  2060.         return "is duplicate";
  2061.     }

  2063.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2064.         scf->upstream.cache = 0;
  2065.         return NGX_CONF_OK;
  2066.     }

  2068.     if (scf->upstream.store > 0) {
  2069.         return "is incompatible with \"scgi_store\"";
  2070.     }

  2072.     scf->upstream.cache = 1;

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

  2076.     ccv.cf = cf;
  2077.     ccv.value = &value[1];
  2078.     ccv.complex_value = &cv;

  2080.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2081.         return NGX_CONF_ERROR;
  2082.     }

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

  2086.         scf->upstream.cache_value = ngx_palloc(cf->pool,
  2087.                                              sizeof(ngx_http_complex_value_t));
  2088.         if (scf->upstream.cache_value == NULL) {
  2089.             return NGX_CONF_ERROR;
  2090.         }

  2092.         *scf->upstream.cache_value = cv;

  2094.         return NGX_CONF_OK;
  2095.     }

  2097.     scf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2098.                                                      &ngx_http_scgi_module);
  2099.     if (scf->upstream.cache_zone == NULL) {
  2100.         return NGX_CONF_ERROR;
  2101.     }

  2103.     return NGX_CONF_OK;
  2104. }


  2107. static char *
  2108. ‌ngx_http_scgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2109. {
  2110.     ngx_http_scgi_loc_conf_t *scf = conf;

  2112.     ngx_str_t                         *value;
  2113.     ngx_http_compile_complex_value_t   ccv;

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

  2117.     if (scf->cache_key.value.data) {
  2118.         return "is duplicate";
  2119.     }

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

  2123.     ccv.cf = cf;
  2124.     ccv.value = &value[1];
  2125.     ccv.complex_value = &scf->cache_key;

  2127.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2128.         return NGX_CONF_ERROR;
  2129.     }

  2131.     return NGX_CONF_OK;
  2132. }

  2134. #endif

One Level Up Top Level