One Level Up Top Level

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

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_socket_rcvbuf"),
  155.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  156.       ngx_conf_set_size_slot,
  157.       NGX_HTTP_LOC_CONF_OFFSET,
  158.       offsetof(ngx_http_scgi_loc_conf_t, upstream.socket_rcvbuf),
  159.       NULL },

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

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

  175.     { ngx_string("scgi_send_timeout"),
  176.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  177.       ngx_conf_set_msec_slot,
  178.       NGX_HTTP_LOC_CONF_OFFSET,
  179.       offsetof(ngx_http_scgi_loc_conf_t, upstream.send_timeout),
  180.       NULL },

  182.     { ngx_string("scgi_buffer_size"),
  183.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  184.       ngx_conf_set_size_slot,
  185.       NGX_HTTP_LOC_CONF_OFFSET,
  186.       offsetof(ngx_http_scgi_loc_conf_t, upstream.buffer_size),
  187.       NULL },

  189.     { ngx_string("scgi_pass_request_headers"),
  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.pass_request_headers),
  194.       NULL },

  196.     { ngx_string("scgi_pass_request_body"),
  197.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  198.       ngx_conf_set_flag_slot,
  199.       NGX_HTTP_LOC_CONF_OFFSET,
  200.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_request_body),
  201.       NULL },

  203.     { ngx_string("scgi_intercept_errors"),
  204.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  205.       ngx_conf_set_flag_slot,
  206.       NGX_HTTP_LOC_CONF_OFFSET,
  207.       offsetof(ngx_http_scgi_loc_conf_t, upstream.intercept_errors),
  208.       NULL },

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

  217.     { ngx_string("scgi_buffers"),
  218.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  219.       ngx_conf_set_bufs_slot,
  220.       NGX_HTTP_LOC_CONF_OFFSET,
  221.       offsetof(ngx_http_scgi_loc_conf_t, upstream.bufs),
  222.       NULL },

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

  231.     { ngx_string("scgi_force_ranges"),
  232.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  233.       ngx_conf_set_flag_slot,
  234.       NGX_HTTP_LOC_CONF_OFFSET,
  235.       offsetof(ngx_http_scgi_loc_conf_t, upstream.force_ranges),
  236.       NULL },

  238.     { ngx_string("scgi_limit_rate"),
  239.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  240.       ngx_http_set_complex_value_size_slot,
  241.       NGX_HTTP_LOC_CONF_OFFSET,
  242.       offsetof(ngx_http_scgi_loc_conf_t, upstream.limit_rate),
  243.       NULL },

  245. #if (NGX_HTTP_CACHE)

  247.     { ngx_string("scgi_cache"),
  248.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  249.       ngx_http_scgi_cache,
  250.       NGX_HTTP_LOC_CONF_OFFSET,
  251.       0,
  252.       NULL },

  254.     { ngx_string("scgi_cache_key"),
  255.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  256.       ngx_http_scgi_cache_key,
  257.       NGX_HTTP_LOC_CONF_OFFSET,
  258.       0,
  259.       NULL },

  261.     { ngx_string("scgi_cache_path"),
  262.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  263.       ngx_http_file_cache_set_slot,
  264.       NGX_HTTP_MAIN_CONF_OFFSET,
  265.       offsetof(ngx_http_scgi_main_conf_t, caches),
  266.       &ngx_http_scgi_module },

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

  275.     { ngx_string("scgi_no_cache"),
  276.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  277.       ngx_http_set_predicate_slot,
  278.       NGX_HTTP_LOC_CONF_OFFSET,
  279.       offsetof(ngx_http_scgi_loc_conf_t, upstream.no_cache),
  280.       NULL },

  282.     { ngx_string("scgi_cache_valid"),
  283.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  284.       ngx_http_file_cache_valid_set_slot,
  285.       NGX_HTTP_LOC_CONF_OFFSET,
  286.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_valid),
  287.       NULL },

  289.     { ngx_string("scgi_cache_min_uses"),
  290.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  291.       ngx_conf_set_num_slot,
  292.       NGX_HTTP_LOC_CONF_OFFSET,
  293.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_min_uses),
  294.       NULL },

  296.     { ngx_string("scgi_cache_max_range_offset"),
  297.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  298.       ngx_conf_set_off_slot,
  299.       NGX_HTTP_LOC_CONF_OFFSET,
  300.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_max_range_offset),
  301.       NULL },

  303.     { ngx_string("scgi_cache_use_stale"),
  304.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  305.       ngx_conf_set_bitmask_slot,
  306.       NGX_HTTP_LOC_CONF_OFFSET,
  307.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_use_stale),
  308.       &ngx_http_scgi_next_upstream_masks },

  310.     { ngx_string("scgi_cache_methods"),
  311.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  312.       ngx_conf_set_bitmask_slot,
  313.       NGX_HTTP_LOC_CONF_OFFSET,
  314.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_methods),
  315.       &ngx_http_upstream_cache_method_mask },

  317.     { ngx_string("scgi_cache_lock"),
  318.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  319.       ngx_conf_set_flag_slot,
  320.       NGX_HTTP_LOC_CONF_OFFSET,
  321.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock),
  322.       NULL },

  324.     { ngx_string("scgi_cache_lock_timeout"),
  325.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  326.       ngx_conf_set_msec_slot,
  327.       NGX_HTTP_LOC_CONF_OFFSET,
  328.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock_timeout),
  329.       NULL },

  331.     { ngx_string("scgi_cache_lock_age"),
  332.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  333.       ngx_conf_set_msec_slot,
  334.       NGX_HTTP_LOC_CONF_OFFSET,
  335.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock_age),
  336.       NULL },

  338.     { ngx_string("scgi_cache_revalidate"),
  339.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  340.       ngx_conf_set_flag_slot,
  341.       NGX_HTTP_LOC_CONF_OFFSET,
  342.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_revalidate),
  343.       NULL },

  345.     { ngx_string("scgi_cache_background_update"),
  346.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  347.       ngx_conf_set_flag_slot,
  348.       NGX_HTTP_LOC_CONF_OFFSET,
  349.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_background_update),
  350.       NULL },

  352. #endif

  354.     { ngx_string("scgi_temp_path"),
  355.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  356.       ngx_conf_set_path_slot,
  357.       NGX_HTTP_LOC_CONF_OFFSET,
  358.       offsetof(ngx_http_scgi_loc_conf_t, upstream.temp_path),
  359.       NULL },

  361.     { ngx_string("scgi_max_temp_file_size"),
  362.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  363.       ngx_conf_set_size_slot,
  364.       NGX_HTTP_LOC_CONF_OFFSET,
  365.       offsetof(ngx_http_scgi_loc_conf_t, upstream.max_temp_file_size_conf),
  366.       NULL },

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

  375.     { ngx_string("scgi_next_upstream"),
  376.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  377.       ngx_conf_set_bitmask_slot,
  378.       NGX_HTTP_LOC_CONF_OFFSET,
  379.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream),
  380.       &ngx_http_scgi_next_upstream_masks },

  382.     { ngx_string("scgi_next_upstream_tries"),
  383.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  384.       ngx_conf_set_num_slot,
  385.       NGX_HTTP_LOC_CONF_OFFSET,
  386.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream_tries),
  387.       NULL },

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

  396.     { ngx_string("scgi_param"),
  397.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  398.       ngx_http_upstream_param_set_slot,
  399.       NGX_HTTP_LOC_CONF_OFFSET,
  400.       offsetof(ngx_http_scgi_loc_conf_t, params_source),
  401.       NULL },

  403.     { ngx_string("scgi_pass_header"),
  404.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  405.       ngx_conf_set_str_array_slot,
  406.       NGX_HTTP_LOC_CONF_OFFSET,
  407.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_headers),
  408.       NULL },

  410.     { ngx_string("scgi_hide_header"),
  411.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  412.       ngx_conf_set_str_array_slot,
  413.       NGX_HTTP_LOC_CONF_OFFSET,
  414.       offsetof(ngx_http_scgi_loc_conf_t, upstream.hide_headers),
  415.       NULL },

  417.     { ngx_string("scgi_ignore_headers"),
  418.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  419.       ngx_conf_set_bitmask_slot,
  420.       NGX_HTTP_LOC_CONF_OFFSET,
  421.       offsetof(ngx_http_scgi_loc_conf_t, upstream.ignore_headers),
  422.       &ngx_http_upstream_ignore_headers_masks },

  424.       ngx_null_command
  425. };


  428. ‌static ngx_http_module_t ngx_http_scgi_module_ctx = {
  429.     NULL,                                  /* preconfiguration */
  430.     NULL,                                  /* postconfiguration */

  432.     ngx_http_scgi_create_main_conf,        /* create main configuration */
  433.     NULL,                                  /* init main configuration */

  435.     NULL,                                  /* create server configuration */
  436.     NULL,                                  /* merge server configuration */

  438.     ngx_http_scgi_create_loc_conf,         /* create location configuration */
  439.     ngx_http_scgi_merge_loc_conf           /* merge location configuration */
  440. };


  443. ‌ngx_module_t ngx_http_scgi_module = {
  444.     NGX_MODULE_V1,
  445.     &ngx_http_scgi_module_ctx,             /* module context */
  446.     ngx_http_scgi_commands,                /* module directives */
  447.     NGX_HTTP_MODULE,                       /* module type */
  448.     NULL,                                  /* init master */
  449.     NULL,                                  /* init module */
  450.     NULL,                                  /* init process */
  451.     NULL,                                  /* init thread */
  452.     NULL,                                  /* exit thread */
  453.     NULL,                                  /* exit process */
  454.     NULL,                                  /* exit master */
  455.     NGX_MODULE_V1_PADDING
  456. };


  459. ‌static ngx_str_t ngx_http_scgi_hide_headers[] = {
  460.     ngx_string("Status"),
  461.     ngx_string("X-Accel-Expires"),
  462.     ngx_string("X-Accel-Redirect"),
  463.     ngx_string("X-Accel-Limit-Rate"),
  464.     ngx_string("X-Accel-Buffering"),
  465.     ngx_string("X-Accel-Charset"),
  466.     ngx_null_string
  467. };


  470. ‌static ngx_keyval_t  ngx_http_scgi_headers[] = {
  471.     { ngx_string("HTTP_HOST"),
  472.       ngx_string("$host$is_request_port$request_port") },
  473.     { ngx_null_string, ngx_null_string }
  474. };


  477. #if (NGX_HTTP_CACHE)

  479. ‌static ngx_keyval_t  ngx_http_scgi_cache_headers[] = {
  480.     { ngx_string("HTTP_HOST"),
  481.       ngx_string("$host$is_request_port$request_port") },
  482.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  483.       ngx_string("$upstream_cache_last_modified") },
  484.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  485.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  486.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  487.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  488.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  489.     { ngx_null_string, ngx_null_string }
  490. };

  492. #endif


  495. ‌static ngx_path_init_t ngx_http_scgi_temp_path = {
  496.     ngx_string(NGX_HTTP_SCGI_TEMP_PATH), { 1, 2, 0 }
  497. };


  500. static ngx_int_t
  501. ‌ngx_http_scgi_handler(ngx_http_request_t *r)
  502. {
  503.     ngx_int_t                   rc;
  504.     ngx_http_status_t          *status;
  505.     ngx_http_upstream_t        *u;
  506.     ngx_http_scgi_loc_conf_t   *scf;
  507. #if (NGX_HTTP_CACHE)
  508.     ngx_http_scgi_main_conf_t  *smcf;
  509. #endif

  511.     if (ngx_http_upstream_create(r) != NGX_OK) {
  512.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  513.     }

  515.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  516.     if (status == NULL) {
  517.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  518.     }

  520.     ngx_http_set_ctx(r, status, ngx_http_scgi_module);

  522.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  524.     if (scf->scgi_lengths) {
  525.         if (ngx_http_scgi_eval(r, scf) != NGX_OK) {
  526.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  527.         }
  528.     }

  530.     u = r->upstream;

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

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

  537. #if (NGX_HTTP_CACHE)
  538.     smcf = ngx_http_get_module_main_conf(r, ngx_http_scgi_module);

  540.     u->caches = &smcf->caches;
  541.     u->create_key = ngx_http_scgi_create_key;
  542. #endif

  544.     u->create_request = ngx_http_scgi_create_request;
  545.     u->reinit_request = ngx_http_scgi_reinit_request;
  546.     u->process_header = ngx_http_scgi_process_status_line;
  547.     u->abort_request = ngx_http_scgi_abort_request;
  548.     u->finalize_request = ngx_http_scgi_finalize_request;
  549.     r->state = 0;

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

  553.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  554.     if (u->pipe == NULL) {
  555.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  556.     }

  558.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  559.     u->pipe->input_ctx = r;

  561.     u->input_filter_init = ngx_http_scgi_input_filter_init;
  562.     u->input_filter = ngx_http_upstream_non_buffered_filter;
  563.     u->input_filter_ctx = r;

  565.     if (!scf->upstream.request_buffering
  566.         && scf->upstream.pass_request_body
  567.         && !r->headers_in.chunked)
  568.     {
  569.         r->request_body_no_buffering = 1;
  570.     }

  572.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  574.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  575.         return rc;
  576.     }

  578.     return NGX_DONE;
  579. }


  582. static ngx_int_t
  583. ‌ngx_http_scgi_eval(ngx_http_request_t *r, ngx_http_scgi_loc_conf_t * scf)
  584. {
  585.     ngx_url_t             url;
  586.     ngx_http_upstream_t  *u;

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

  590.     if (ngx_http_script_run(r, &url.url, scf->scgi_lengths->elts, 0,
  591.                             scf->scgi_values->elts)
  592.         == NULL)
  593.     {
  594.         return NGX_ERROR;
  595.     }

  597.     url.no_resolve = 1;

  599.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  600.         if (url.err) {
  601.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  602.                           "%s in upstream \"%V\"", url.err, &url.url);
  603.         }

  605.         return NGX_ERROR;
  606.     }

  608.     u = r->upstream;

  610.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  611.     if (u->resolved == NULL) {
  612.         return NGX_ERROR;
  613.     }

  615.     if (url.addrs) {
  616.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  617.         u->resolved->socklen = url.addrs[0].socklen;
  618.         u->resolved->name = url.addrs[0].name;
  619.         u->resolved->naddrs = 1;
  620.     }

  622.     u->resolved->host = url.host;
  623.     u->resolved->port = url.port;
  624.     u->resolved->no_port = url.no_port;

  626.     return NGX_OK;
  627. }


  630. #if (NGX_HTTP_CACHE)

  632. static ngx_int_t
  633. ‌ngx_http_scgi_create_key(ngx_http_request_t *r)
  634. {
  635.     ngx_str_t                 *key;
  636.     ngx_http_scgi_loc_conf_t  *scf;

  638.     key = ngx_array_push(&r->cache->keys);
  639.     if (key == NULL) {
  640.         return NGX_ERROR;
  641.     }

  643.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  645.     if (ngx_http_complex_value(r, &scf->cache_key, key) != NGX_OK) {
  646.         return NGX_ERROR;
  647.     }

  649.     return NGX_OK;
  650. }

  652. #endif


  655. static ngx_int_t
  656. ‌ngx_http_scgi_create_request(ngx_http_request_t *r)
  657. {
  658.     off_t                         content_length_n;
  659.     u_char                        ch, sep, *key, *val, *lowcase_key;
  660.     size_t                        len, params_len, key_len, val_len, allocated;
  661.     ngx_buf_t                    *b;
  662.     ngx_str_t                     content_length;
  663.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  664.     ngx_chain_t                  *cl, *body;
  665.     ngx_list_part_t              *part;
  666.     ngx_table_elt_t              *header, *hn, **ignored;
  667.     ngx_http_scgi_params_t       *params;
  668.     ngx_http_script_code_pt       code;
  669.     ngx_http_script_engine_t      e, le;
  670.     ngx_http_scgi_loc_conf_t     *scf;
  671.     ngx_http_script_len_code_pt   lcode;
  672.     u_char                        buffer[NGX_OFF_T_LEN];

  674.     content_length_n = 0;

  676.     if (r->headers_in.content_length_n > 0) {
  677.         content_length_n = r->headers_in.content_length_n;
  678.     }

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

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

  685.     params_len = 0;
  686.     header_params = 0;
  687.     ignored = NULL;

  689.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  691. #if (NGX_HTTP_CACHE)
  692.     params = r->upstream->cacheable ? &scf->params_cache : &scf->params;
  693. #else
  694.     params = &scf->params;
  695. #endif

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

  700.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  701.         le.flushed = 1;

  703.         le.ip = params->lengths->elts;
  704.         le.request = r;

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

  708.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  709.             key_len = lcode(&le);

  711.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  712.             skip_empty = lcode(&le);

  714.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  715.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  716.             }
  717.             le.ip += sizeof(uintptr_t);

  719.             if (skip_empty && val_len == 0) {
  720.                 continue;
  721.             }

  723.             params_len += key_len + val_len + 1;
  724.         }

  726.         len += params_len;
  727.     }

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

  731.         allocated = 0;
  732.         lowcase_key = NULL;

  734.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  735.             return NGX_ERROR;
  736.         }

  738.         if (params->number || r->headers_in.multi) {
  739.             n = 0;
  740.             part = &r->headers_in.headers.part;

  742.             while (part) {
  743.                 n += part->nelts;
  744.                 part = part->next;
  745.             }

  747.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  748.             if (ignored == NULL) {
  749.                 return NGX_ERROR;
  750.             }
  751.         }

  753.         part = &r->headers_in.headers.part;
  754.         header = part->elts;

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

  758.             if (i >= part->nelts) {
  759.                 if (part->next == NULL) {
  760.                     break;
  761.                 }

  763.                 part = part->next;
  764.                 header = part->elts;
  765.                 i = 0;
  766.             }

  768.             for (n = 0; n < header_params; n++) {
  769.                 if (&header[i] == ignored[n]) {
  770.                     goto next_length;
  771.                 }
  772.             }

  774.             if (params->number) {
  775.                 if (allocated < header[i].key.len) {
  776.                     allocated = header[i].key.len + 16;
  777.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  778.                     if (lowcase_key == NULL) {
  779.                         return NGX_ERROR;
  780.                     }
  781.                 }

  783.                 hash = 0;

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

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

  791.                     } else if (ch == '-') {
  792.                         ch = '_';
  793.                     }

  795.                     hash = ngx_hash(hash, ch);
  796.                     lowcase_key[n] = ch;
  797.                 }

  799.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  800.                     ignored[header_params++] = &header[i];
  801.                     continue;
  802.                 }
  803.             }

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

  808.             for (hn = header[i].next; hn; hn = hn->next) {
  809.                 len += hn->value.len + 2;
  810.                 ignored[header_params++] = hn;
  811.             }

  813.         next_length:

  815.             continue;
  816.         }
  817.     }

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

  821.     b = ngx_create_temp_buf(r->pool, NGX_SIZE_T_LEN + 1 + len + 1);
  822.     if (b == NULL) {
  823.         return NGX_ERROR;
  824.     }

  826.     cl = ngx_alloc_chain_link(r->pool);
  827.     if (cl == NULL) {
  828.         return NGX_ERROR;
  829.     }

  831.     cl->buf = b;

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

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

  839.         e.ip = params->values->elts;
  840.         e.pos = b->last;
  841.         e.end = b->last + params_len;
  842.         e.request = r;
  843.         e.flushed = 1;

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

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

  849.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  850.             lcode(&le); /* key length */

  852.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  853.             skip_empty = lcode(&le);

  855.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  856.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  857.             }
  858.             le.ip += sizeof(uintptr_t);

  860.             if (skip_empty && val_len == 0) {
  861.                 e.skip = 1;

  863.                 while (*(uintptr_t *) e.ip) {
  864.                     code = *(ngx_http_script_code_pt *) e.ip;
  865.                     code((ngx_http_script_engine_t *) &e);
  866.                 }
  867.                 e.ip += sizeof(uintptr_t);

  869.                 e.skip = 0;

  871.                 continue;
  872.             }

  874. #if (NGX_DEBUG)
  875.             key = e.pos;
  876. #endif
  877.             code = *(ngx_http_script_code_pt *) e.ip;
  878.             code((ngx_http_script_engine_t *) &e);

  880.             if (e.status) {
  881.                 return NGX_ERROR;
  882.             }

  884. #if (NGX_DEBUG)
  885.             val = e.pos;
  886. #endif
  887.             while (*(uintptr_t *) e.ip) {
  888.                 code = *(ngx_http_script_code_pt *) e.ip;
  889.                 code((ngx_http_script_engine_t *) &e);
  890.             }

  892.             if (e.status) {
  893.                 return NGX_ERROR;
  894.             }

  896.             if (ngx_http_script_check_length(&e, 1) != NGX_OK) {
  897.                 return NGX_ERROR;
  898.             }

  900.             *e.pos++ = '\0';
  901.             e.ip += sizeof(uintptr_t);

  903.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  904.                            "scgi param: \"%s: %s\"", key, val);
  905.         }

  907.         if (e.pos != e.end) {
  908.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  909.                           "scgi request length mismatch");
  910.             return NGX_ERROR;
  911.         }

  913.         b->last = e.pos;
  914.     }

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

  918.         part = &r->headers_in.headers.part;
  919.         header = part->elts;

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

  923.             if (i >= part->nelts) {
  924.                 if (part->next == NULL) {
  925.                     break;
  926.                 }

  928.                 part = part->next;
  929.                 header = part->elts;
  930.                 i = 0;
  931.             }

  933.             for (n = 0; n < header_params; n++) {
  934.                 if (&header[i] == ignored[n]) {
  935.                     goto next_value;
  936.                 }
  937.             }

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

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

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

  948.                 } else if (ch == '-') {
  949.                     ch = '_';
  950.                 }

  952.                 *b->last++ = ch;
  953.             }

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

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

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

  962.                 if (header[i].key.len == sizeof("Cookie") - 1
  963.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  964.                                        sizeof("Cookie") - 1)
  965.                        == 0)
  966.                 {
  967.                     sep = ';';

  969.                 } else {
  970.                     sep = ',';
  971.                 }

  973.                 for (hn = header[i].next; hn; hn = hn->next) {
  974.                     *b->last++ = sep;
  975.                     *b->last++ = ' ';
  976.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  977.                 }
  978.             }

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

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

  985.         next_value:

  987.             continue;
  988.         }
  989.     }

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

  993.     if (r->request_body_no_buffering) {
  994.         r->upstream->request_bufs = cl;

  996.     } else if (scf->upstream.pass_request_body) {
  997.         body = r->upstream->request_bufs;
  998.         r->upstream->request_bufs = cl;

  1000.         while (body) {
  1001.             b = ngx_alloc_buf(r->pool);
  1002.             if (b == NULL) {
  1003.                 return NGX_ERROR;
  1004.             }

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

  1008.             cl->next = ngx_alloc_chain_link(r->pool);
  1009.             if (cl->next == NULL) {
  1010.                 return NGX_ERROR;
  1011.             }

  1013.             cl = cl->next;
  1014.             cl->buf = b;

  1016.             body = body->next;
  1017.         }

  1019.     } else {
  1020.         r->upstream->request_bufs = cl;
  1021.     }

  1023.     cl->next = NULL;

  1025.     return NGX_OK;
  1026. }


  1029. static ngx_int_t
  1030. ‌ngx_http_scgi_reinit_request(ngx_http_request_t *r)
  1031. {
  1032.     ngx_http_status_t  *status;

  1034.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  1036.     if (status == NULL) {
  1037.         return NGX_OK;
  1038.     }

  1040.     status->code = 0;
  1041.     status->count = 0;
  1042.     status->start = NULL;
  1043.     status->end = NULL;

  1045.     r->upstream->process_header = ngx_http_scgi_process_status_line;
  1046.     r->state = 0;

  1048.     return NGX_OK;
  1049. }


  1052. static ngx_int_t
  1053. ‌ngx_http_scgi_process_status_line(ngx_http_request_t *r)
  1054. {
  1055.     size_t                len;
  1056.     ngx_int_t             rc;
  1057.     ngx_http_status_t    *status;
  1058.     ngx_http_upstream_t  *u;

  1060.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  1062.     if (status == NULL) {
  1063.         return NGX_ERROR;
  1064.     }

  1066.     u = r->upstream;

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

  1070.     if (rc == NGX_AGAIN) {
  1071.         return rc;
  1072.     }

  1074.     if (rc == NGX_ERROR) {
  1075.         u->process_header = ngx_http_scgi_process_header;
  1076.         u->buffer.pos = status->line_start;
  1077.         r->state = 0;
  1078.         return ngx_http_scgi_process_header(r);
  1079.     }

  1081.     if (u->state && u->state->status == 0) {
  1082.         u->state->status = status->code;
  1083.     }

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

  1087.     len = status->end - status->start;
  1088.     u->headers_in.status_line.len = len;

  1090.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1091.     if (u->headers_in.status_line.data == NULL) {
  1092.         return NGX_ERROR;
  1093.     }

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

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

  1101.     u->process_header = ngx_http_scgi_process_header;

  1103.     return ngx_http_scgi_process_header(r);
  1104. }


  1107. static ngx_int_t
  1108. ‌ngx_http_scgi_process_header(ngx_http_request_t *r)
  1109. {
  1110.     ngx_str_t                      *status_line;
  1111.     ngx_int_t                       rc, status;
  1112.     ngx_table_elt_t                *h;
  1113.     ngx_http_upstream_t            *u;
  1114.     ngx_http_upstream_header_t     *hh;
  1115.     ngx_http_upstream_main_conf_t  *umcf;

  1117.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1119.     for ( ;; ) {

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

  1123.         if (rc == NGX_OK) {

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

  1127.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1128.             if (h == NULL) {
  1129.                 return NGX_ERROR;
  1130.             }

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

  1134.             h->key.len = r->header_name_end - r->header_name_start;
  1135.             h->value.len = r->header_end - r->header_start;

  1137.             h->key.data = ngx_pnalloc(r->pool,
  1138.                                       h->key.len + 1 + h->value.len + 1
  1139.                                       + h->key.len);
  1140.             if (h->key.data == NULL) {
  1141.                 h->hash = 0;
  1142.                 return NGX_ERROR;
  1143.             }

  1145.             h->value.data = h->key.data + h->key.len + 1;
  1146.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1148.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1149.             h->key.data[h->key.len] = '\0';
  1150.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1151.             h->value.data[h->value.len] = '\0';

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

  1156.             } else {
  1157.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1158.             }

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

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

  1166.                 if (rc != NGX_OK) {
  1167.                     return rc;
  1168.                 }
  1169.             }

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

  1174.             continue;
  1175.         }

  1177.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1184.             u = r->upstream;

  1186.             if (u->headers_in.status_n) {
  1187.                 goto done;
  1188.             }

  1190.             if (u->headers_in.status) {
  1191.                 status_line = &u->headers_in.status->value;

  1193.                 status = ngx_atoi(status_line->data, 3);
  1194.                 if (status == NGX_ERROR) {
  1195.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1196.                                   "upstream sent invalid status \"%V\"",
  1197.                                   status_line);
  1198.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1199.                 }

  1201.                 u->headers_in.status_n = status;

  1203.                 if (status_line->len > 3) {
  1204.                     u->headers_in.status_line = *status_line;
  1205.                 }

  1207.             } else if (u->headers_in.location) {
  1208.                 u->headers_in.status_n = 302;
  1209.                 ngx_str_set(&u->headers_in.status_line,
  1210.                             "302 Moved Temporarily");

  1212.             } else {
  1213.                 u->headers_in.status_n = 200;
  1214.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1215.             }

  1217.             if (u->state && u->state->status == 0) {
  1218.                 u->state->status = u->headers_in.status_n;
  1219.             }

  1221.         done:

  1223.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1224.                 && r->headers_in.upgrade)
  1225.             {
  1226.                 u->upgrade = 1;
  1227.             }

  1229.             return NGX_OK;
  1230.         }

  1232.         if (rc == NGX_AGAIN) {
  1233.             return NGX_AGAIN;
  1234.         }

  1236.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1238.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1239.                       "upstream sent invalid header: \"%*s\\x%02xd...\"",
  1240.                       r->header_end - r->header_name_start,
  1241.                       r->header_name_start, *r->header_end);

  1243.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1244.     }
  1245. }


  1248. static ngx_int_t
  1249. ‌ngx_http_scgi_input_filter_init(void *data)
  1250. {
  1251.     ngx_http_request_t   *r = data;
  1252.     ngx_http_upstream_t  *u;

  1254.     u = r->upstream;

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

  1260.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1261.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  1262.     {
  1263.         u->pipe->length = 0;
  1264.         u->length = 0;

  1266.     } else if (r->method == NGX_HTTP_HEAD) {
  1267.         u->pipe->length = -1;
  1268.         u->length = -1;

  1270.     } else {
  1271.         u->pipe->length = u->headers_in.content_length_n;
  1272.         u->length = u->headers_in.content_length_n;
  1273.     }

  1275.     return NGX_OK;
  1276. }


  1279. static void
  1280. ‌ngx_http_scgi_abort_request(ngx_http_request_t *r)
  1281. {
  1282.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1283.                    "abort http scgi request");

  1285.     return;
  1286. }


  1289. static void
  1290. ‌ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1291. {
  1292.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1293.                    "finalize http scgi request");

  1295.     return;
  1296. }


  1299. static void *
  1300. ‌ngx_http_scgi_create_main_conf(ngx_conf_t *cf)
  1301. {
  1302.     ngx_http_scgi_main_conf_t  *conf;

  1304.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_main_conf_t));
  1305.     if (conf == NULL) {
  1306.         return NULL;
  1307.     }

  1309. #if (NGX_HTTP_CACHE)
  1310.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1311.                        sizeof(ngx_http_file_cache_t *))
  1312.         != NGX_OK)
  1313.     {
  1314.         return NULL;
  1315.     }
  1316. #endif

  1318.     return conf;
  1319. }


  1322. static void *
  1323. ‌ngx_http_scgi_create_loc_conf(ngx_conf_t *cf)
  1324. {
  1325.     ngx_http_scgi_loc_conf_t  *conf;

  1327.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_loc_conf_t));
  1328.     if (conf == NULL) {
  1329.         return NULL;
  1330.     }

  1332.     /*
  1333.      * set by ngx_pcalloc():
  1334.      *
  1335.      *     conf->upstream.bufs.num = 0;
  1336.      *     conf->upstream.ignore_headers = 0;
  1337.      *     conf->upstream.next_upstream = 0;
  1338.      *     conf->upstream.cache_zone = NULL;
  1339.      *     conf->upstream.cache_use_stale = 0;
  1340.      *     conf->upstream.cache_methods = 0;
  1341.      *     conf->upstream.temp_path = NULL;
  1342.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  1343.      *     conf->upstream.store_lengths = NULL;
  1344.      *     conf->upstream.store_values = NULL;
  1345.      */

  1347.     conf->upstream.store = NGX_CONF_UNSET;
  1348.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1349.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1350.     conf->upstream.buffering = NGX_CONF_UNSET;
  1351.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  1352.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1353.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1355.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  1356.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  1357.     conf->upstream.socket_rcvbuf = NGX_CONF_UNSET_SIZE;
  1358.     conf->upstream.socket_sndbuf = NGX_CONF_UNSET_SIZE;

  1360.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1361.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1362.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1363.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1365.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1366.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1367.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  1369.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1370.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1371.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1373.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1374.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1376. #if (NGX_HTTP_CACHE)
  1377.     conf->upstream.cache = NGX_CONF_UNSET;
  1378.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1379.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  1380.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1381.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1382.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1383.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1384.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1385.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1386.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1387.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  1388. #endif

  1390.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1391.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1393.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1395.     /* "scgi_cyclic_temp_file" is disabled */
  1396.     conf->upstream.cyclic_temp_file = 0;

  1398.     conf->upstream.change_buffering = 1;

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

  1402.     return conf;
  1403. }


  1406. static char *
  1407. ‌ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1408. {
  1409.     ngx_http_scgi_loc_conf_t *prev = parent;
  1410.     ngx_http_scgi_loc_conf_t *conf = child;

  1412.     size_t                        size;
  1413.     ngx_int_t                     rc;
  1414.     ngx_hash_init_t               hash;
  1415.     ngx_http_core_loc_conf_t     *clcf;

  1417. #if (NGX_HTTP_CACHE)

  1419.     if (conf->upstream.store > 0) {
  1420.         conf->upstream.cache = 0;
  1421.     }

  1423.     if (conf->upstream.cache > 0) {
  1424.         conf->upstream.store = 0;
  1425.     }

  1427. #endif

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

  1432.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1433.         conf->upstream.store_values = prev->upstream.store_values;
  1434.     }

  1436.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1437.                               prev->upstream.store_access, 0600);

  1439.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1440.                               prev->upstream.next_upstream_tries, 0);

  1442.     ngx_conf_merge_value(conf->upstream.buffering,
  1443.                               prev->upstream.buffering, 1);

  1445.     ngx_conf_merge_value(conf->upstream.request_buffering,
  1446.                               prev->upstream.request_buffering, 1);

  1448.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1449.                               prev->upstream.ignore_client_abort, 0);

  1451.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1452.                               prev->upstream.force_ranges, 0);

  1454.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1455.                               prev->upstream.local, NULL);

  1457.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  1458.                               prev->upstream.socket_keepalive, 0);

  1460.     ngx_conf_merge_size_value(conf->upstream.socket_rcvbuf,
  1461.                               prev->upstream.socket_rcvbuf, 0);

  1463.     ngx_conf_merge_size_value(conf->upstream.socket_sndbuf,
  1464.                               prev->upstream.socket_sndbuf, 0);

  1466.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1467.                               prev->upstream.connect_timeout, 60000);

  1469.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1470.                               prev->upstream.send_timeout, 60000);

  1472.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1473.                               prev->upstream.read_timeout, 60000);

  1475.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1476.                               prev->upstream.next_upstream_timeout, 0);

  1478.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1479.                               prev->upstream.send_lowat, 0);

  1481.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1482.                               prev->upstream.buffer_size,
  1483.                               (size_t) ngx_pagesize);

  1485.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  1486.                               prev->upstream.limit_rate, NULL);


  1489.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1490.                               8, ngx_pagesize);

  1492.     if (conf->upstream.bufs.num < 2) {
  1493.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1494.                            "there must be at least 2 \"scgi_buffers\"");
  1495.         return NGX_CONF_ERROR;
  1496.     }


  1499.     size = conf->upstream.buffer_size;
  1500.     if (size < conf->upstream.bufs.size) {
  1501.         size = conf->upstream.bufs.size;
  1502.     }


  1505.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1506.                               prev->upstream.busy_buffers_size_conf,
  1507.                               NGX_CONF_UNSET_SIZE);

  1509.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1510.         conf->upstream.busy_buffers_size = 2 * size;
  1511.     } else {
  1512.         conf->upstream.busy_buffers_size =
  1513.             conf->upstream.busy_buffers_size_conf;
  1514.     }

  1516.     if (conf->upstream.busy_buffers_size < size) {
  1517.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1518.             "\"scgi_busy_buffers_size\" must be equal to or greater "
  1519.             "than the maximum of the value of \"scgi_buffer_size\" and "
  1520.             "one of the \"scgi_buffers\"");

  1522.         return NGX_CONF_ERROR;
  1523.     }

  1525.     if (conf->upstream.busy_buffers_size
  1526.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1527.     {
  1528.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1529.             "\"scgi_busy_buffers_size\" must be less than "
  1530.             "the size of all \"scgi_buffers\" minus one buffer");

  1532.         return NGX_CONF_ERROR;
  1533.     }


  1536.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1537.                               prev->upstream.temp_file_write_size_conf,
  1538.                               NGX_CONF_UNSET_SIZE);

  1540.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1541.         conf->upstream.temp_file_write_size = 2 * size;
  1542.     } else {
  1543.         conf->upstream.temp_file_write_size =
  1544.             conf->upstream.temp_file_write_size_conf;
  1545.     }

  1547.     if (conf->upstream.temp_file_write_size < size) {
  1548.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1549.             "\"scgi_temp_file_write_size\" must be equal to or greater than "
  1550.             "the maximum of the value of \"scgi_buffer_size\" and "
  1551.             "one of the \"scgi_buffers\"");

  1553.         return NGX_CONF_ERROR;
  1554.     }


  1557.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1558.                               prev->upstream.max_temp_file_size_conf,
  1559.                               NGX_CONF_UNSET_SIZE);

  1561.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1562.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1563.     } else {
  1564.         conf->upstream.max_temp_file_size =
  1565.             conf->upstream.max_temp_file_size_conf;
  1566.     }

  1568.     if (conf->upstream.max_temp_file_size != 0
  1569.         && conf->upstream.max_temp_file_size < size)
  1570.     {
  1571.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1572.             "\"scgi_max_temp_file_size\" must be equal to zero to disable "
  1573.             "temporary files usage or must be equal to or greater than "
  1574.             "the maximum of the value of \"scgi_buffer_size\" and "
  1575.             "one of the \"scgi_buffers\"");

  1577.         return NGX_CONF_ERROR;
  1578.     }


  1581.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1582.                                  prev->upstream.ignore_headers,
  1583.                                  NGX_CONF_BITMASK_SET);


  1586.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1587.                                  prev->upstream.next_upstream,
  1588.                                  (NGX_CONF_BITMASK_SET
  1589.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1590.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1592.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1593.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1594.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1595.     }

  1597.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1598.                                   prev->upstream.temp_path,
  1599.                                   &ngx_http_scgi_temp_path)
  1600.         != NGX_CONF_OK)
  1601.     {
  1602.         return NGX_CONF_ERROR;
  1603.     }

  1605. #if (NGX_HTTP_CACHE)

  1607.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1608.         ngx_conf_merge_value(conf->upstream.cache,
  1609.                               prev->upstream.cache, 0);

  1611.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1612.         conf->upstream.cache_value = prev->upstream.cache_value;
  1613.     }

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

  1618.         shm_zone = conf->upstream.cache_zone;

  1620.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1621.                            "\"scgi_cache\" zone \"%V\" is unknown",
  1622.                            &shm_zone->shm.name);

  1624.         return NGX_CONF_ERROR;
  1625.     }

  1627.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1628.                               prev->upstream.cache_min_uses, 1);

  1630.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  1631.                               prev->upstream.cache_max_range_offset,
  1632.                               NGX_MAX_OFF_T_VALUE);

  1634.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1635.                               prev->upstream.cache_use_stale,
  1636.                               (NGX_CONF_BITMASK_SET
  1637.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1639.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1640.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1641.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1642.     }

  1644.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1645.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1646.     }

  1648.     if (conf->upstream.cache_methods == 0) {
  1649.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1650.     }

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

  1654.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1655.                              prev->upstream.cache_bypass, NULL);

  1657.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1658.                              prev->upstream.no_cache, NULL);

  1660.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1661.                              prev->upstream.cache_valid, NULL);

  1663.     if (conf->cache_key.value.data == NULL) {
  1664.         conf->cache_key = prev->cache_key;
  1665.     }

  1667.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1668.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1669.                            "no \"scgi_cache_key\" for \"scgi_cache\"");
  1670.     }

  1672.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1673.                               prev->upstream.cache_lock, 0);

  1675.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1676.                               prev->upstream.cache_lock_timeout, 5000);

  1678.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1679.                               prev->upstream.cache_lock_age, 5000);

  1681.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1682.                               prev->upstream.cache_revalidate, 0);

  1684.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  1685.                               prev->upstream.cache_background_update, 0);

  1687. #endif

  1689.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1690.                          prev->upstream.pass_request_headers, 1);
  1691.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1692.                          prev->upstream.pass_request_body, 1);

  1694.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1695.                          prev->upstream.intercept_errors, 0);

  1697.     hash.max_size = 512;
  1698.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1699.     hash.name = "scgi_hide_headers_hash";

  1701.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1702.             &prev->upstream, ngx_http_scgi_hide_headers, &hash)
  1703.         != NGX_OK)
  1704.     {
  1705.         return NGX_CONF_ERROR;
  1706.     }

  1708.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1710.     if (clcf->noname
  1711.         && conf->upstream.upstream == NULL && conf->scgi_lengths == NULL)
  1712.     {
  1713.         conf->upstream.upstream = prev->upstream.upstream;
  1714.         conf->scgi_lengths = prev->scgi_lengths;
  1715.         conf->scgi_values = prev->scgi_values;
  1716.     }

  1718.     if (clcf->lmt_excpt && clcf->handler == NULL
  1719.         && (conf->upstream.upstream || conf->scgi_lengths))
  1720.     {
  1721.         clcf->handler = ngx_http_scgi_handler;
  1722.     }

  1724.     if (conf->params_source == NULL) {
  1725.         conf->params = prev->params;
  1726. #if (NGX_HTTP_CACHE)
  1727.         conf->params_cache = prev->params_cache;
  1728. #endif
  1729.         conf->params_source = prev->params_source;
  1730.     }

  1732.     rc = ngx_http_scgi_init_params(cf, conf, &conf->params,
  1733.                                    ngx_http_scgi_headers);
  1734.     if (rc != NGX_OK) {
  1735.         return NGX_CONF_ERROR;
  1736.     }

  1738. #if (NGX_HTTP_CACHE)

  1740.     if (conf->upstream.cache) {
  1741.         rc = ngx_http_scgi_init_params(cf, conf, &conf->params_cache,
  1742.                                        ngx_http_scgi_cache_headers);
  1743.         if (rc != NGX_OK) {
  1744.             return NGX_CONF_ERROR;
  1745.         }
  1746.     }

  1748. #endif

  1750.     /*
  1751.      * special handling to preserve conf->params in the "http" section
  1752.      * to inherit it to all servers
  1753.      */

  1755.     if (prev->params.hash.buckets == NULL
  1756.         && conf->params_source == prev->params_source)
  1757.     {
  1758.         prev->params = conf->params;
  1759. #if (NGX_HTTP_CACHE)
  1760.         prev->params_cache = conf->params_cache;
  1761. #endif
  1762.     }

  1764.     return NGX_CONF_OK;
  1765. }


  1768. static ngx_int_t
  1769. ‌ngx_http_scgi_init_params(ngx_conf_t *cf, ngx_http_scgi_loc_conf_t *conf,
  1770.     ngx_http_scgi_params_t *params, ngx_keyval_t *default_params)
  1771. {
  1772.     u_char                       *p;
  1773.     size_t                        size;
  1774.     uintptr_t                    *code;
  1775.     ngx_uint_t                    i, nsrc;
  1776.     ngx_array_t                   headers_names, params_merged;
  1777.     ngx_keyval_t                 *h;
  1778.     ngx_hash_key_t               *hk;
  1779.     ngx_hash_init_t               hash;
  1780.     ngx_http_upstream_param_t    *src, *s;
  1781.     ngx_http_script_compile_t     sc;
  1782.     ngx_http_script_copy_code_t  *copy;

  1784.     if (params->hash.buckets) {
  1785.         return NGX_OK;
  1786.     }

  1788.     if (conf->params_source == NULL && default_params == NULL) {
  1789.         params->hash.buckets = (void *) 1;
  1790.         return NGX_OK;
  1791.     }

  1793.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  1794.     if (params->lengths == NULL) {
  1795.         return NGX_ERROR;
  1796.     }

  1798.     params->values = ngx_array_create(cf->pool, 512, 1);
  1799.     if (params->values == NULL) {
  1800.         return NGX_ERROR;
  1801.     }

  1803.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  1804.         != NGX_OK)
  1805.     {
  1806.         return NGX_ERROR;
  1807.     }

  1809.     if (conf->params_source) {
  1810.         src = conf->params_source->elts;
  1811.         nsrc = conf->params_source->nelts;

  1813.     } else {
  1814.         src = NULL;
  1815.         nsrc = 0;
  1816.     }

  1818.     if (default_params) {
  1819.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  1820.                            sizeof(ngx_http_upstream_param_t))
  1821.             != NGX_OK)
  1822.         {
  1823.             return NGX_ERROR;
  1824.         }

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

  1828.             s = ngx_array_push(&params_merged);
  1829.             if (s == NULL) {
  1830.                 return NGX_ERROR;
  1831.             }

  1833.             *s = src[i];
  1834.         }

  1836.         h = default_params;

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

  1840.             src = params_merged.elts;
  1841.             nsrc = params_merged.nelts;

  1843.             for (i = 0; i < nsrc; i++) {
  1844.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  1845.                     goto next;
  1846.                 }
  1847.             }

  1849.             s = ngx_array_push(&params_merged);
  1850.             if (s == NULL) {
  1851.                 return NGX_ERROR;
  1852.             }

  1854.             s->key = h->key;
  1855.             s->value = h->value;
  1856.             s->skip_empty = 1;

  1858.         next:

  1860.             h++;
  1861.         }

  1863.         src = params_merged.elts;
  1864.         nsrc = params_merged.nelts;
  1865.     }

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

  1869.         if (src[i].key.len > sizeof("HTTP_") - 1
  1870.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  1871.         {
  1872.             hk = ngx_array_push(&headers_names);
  1873.             if (hk == NULL) {
  1874.                 return NGX_ERROR;
  1875.             }

  1877.             hk->key.len = src[i].key.len - 5;
  1878.             hk->key.data = src[i].key.data + 5;
  1879.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  1880.             hk->value = (void *) 1;

  1882.             if (src[i].value.len == 0) {
  1883.                 continue;
  1884.             }
  1885.         }

  1887.         copy = ngx_array_push_n(params->lengths,
  1888.                                 sizeof(ngx_http_script_copy_code_t));
  1889.         if (copy == NULL) {
  1890.             return NGX_ERROR;
  1891.         }

  1893.         copy->code = (ngx_http_script_code_pt) (void *)
  1894.                                                  ngx_http_script_copy_len_code;
  1895.         copy->len = src[i].key.len + 1;

  1897.         copy = ngx_array_push_n(params->lengths,
  1898.                                 sizeof(ngx_http_script_copy_code_t));
  1899.         if (copy == NULL) {
  1900.             return NGX_ERROR;
  1901.         }

  1903.         copy->code = (ngx_http_script_code_pt) (void *)
  1904.                                                  ngx_http_script_copy_len_code;
  1905.         copy->len = src[i].skip_empty;


  1908.         size = (sizeof(ngx_http_script_copy_code_t)
  1909.                 + src[i].key.len + 1 + sizeof(uintptr_t) - 1)
  1910.                & ~(sizeof(uintptr_t) - 1);

  1912.         copy = ngx_array_push_n(params->values, size);
  1913.         if (copy == NULL) {
  1914.             return NGX_ERROR;
  1915.         }

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

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


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

  1926.         sc.cf = cf;
  1927.         sc.source = &src[i].value;
  1928.         sc.flushes = &params->flushes;
  1929.         sc.lengths = &params->lengths;
  1930.         sc.values = &params->values;

  1932.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1933.             return NGX_ERROR;
  1934.         }

  1936.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1937.         if (code == NULL) {
  1938.             return NGX_ERROR;
  1939.         }

  1941.         *code = (uintptr_t) NULL;


  1944.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  1945.         if (code == NULL) {
  1946.             return NGX_ERROR;
  1947.         }

  1949.         *code = (uintptr_t) NULL;
  1950.     }

  1952.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1953.     if (code == NULL) {
  1954.         return NGX_ERROR;
  1955.     }

  1957.     *code = (uintptr_t) NULL;

  1959.     params->number = headers_names.nelts;

  1961.     hash.hash = &params->hash;
  1962.     hash.key = ngx_hash_key_lc;
  1963.     hash.max_size = 512;
  1964.     hash.bucket_size = 64;
  1965.     hash.name = "scgi_params_hash";
  1966.     hash.pool = cf->pool;
  1967.     hash.temp_pool = NULL;

  1969.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  1970. }


  1973. static char *
  1974. ‌ngx_http_scgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1975. {
  1976.     ngx_http_scgi_loc_conf_t *scf = conf;

  1978.     ngx_url_t                   u;
  1979.     ngx_str_t                  *value, *url;
  1980.     ngx_uint_t                  n;
  1981.     ngx_http_core_loc_conf_t   *clcf;
  1982.     ngx_http_script_compile_t   sc;

  1984.     if (scf->upstream.upstream || scf->scgi_lengths) {
  1985.         return "is duplicate";
  1986.     }

  1988.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  1989.     clcf->handler = ngx_http_scgi_handler;

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

  1993.     url = &value[1];

  1995.     n = ngx_http_script_variables_count(url);

  1997.     if (n) {

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

  2001.         sc.cf = cf;
  2002.         sc.source = url;
  2003.         sc.lengths = &scf->scgi_lengths;
  2004.         sc.values = &scf->scgi_values;
  2005.         sc.variables = n;
  2006.         sc.complete_lengths = 1;
  2007.         sc.complete_values = 1;

  2009.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2010.             return NGX_CONF_ERROR;
  2011.         }

  2013.         return NGX_CONF_OK;
  2014.     }

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

  2018.     u.url = value[1];
  2019.     u.no_resolve = 1;

  2021.     scf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  2022.     if (scf->upstream.upstream == NULL) {
  2023.         return NGX_CONF_ERROR;
  2024.     }

  2026.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  2027.         clcf->auto_redirect = 1;
  2028.     }

  2030.     return NGX_CONF_OK;
  2031. }


  2034. static char *
  2035. ‌ngx_http_scgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2036. {
  2037.     ngx_http_scgi_loc_conf_t *scf = conf;

  2039.     ngx_str_t                  *value;
  2040.     ngx_http_script_compile_t   sc;

  2042.     if (scf->upstream.store != NGX_CONF_UNSET) {
  2043.         return "is duplicate";
  2044.     }

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

  2048.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2049.         scf->upstream.store = 0;
  2050.         return NGX_CONF_OK;
  2051.     }

  2053.     if (value[1].len == 0) {
  2054.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  2055.         return NGX_CONF_ERROR;
  2056.     }

  2058. #if (NGX_HTTP_CACHE)
  2059.     if (scf->upstream.cache > 0) {
  2060.         return "is incompatible with \"scgi_cache\"";
  2061.     }
  2062. #endif

  2064.     scf->upstream.store = 1;

  2066.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2067.         return NGX_CONF_OK;
  2068.     }

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

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

  2075.     sc.cf = cf;
  2076.     sc.source = &value[1];
  2077.     sc.lengths = &scf->upstream.store_lengths;
  2078.     sc.values = &scf->upstream.store_values;
  2079.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2080.     sc.complete_lengths = 1;
  2081.     sc.complete_values = 1;

  2083.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2084.         return NGX_CONF_ERROR;
  2085.     }

  2087.     return NGX_CONF_OK;
  2088. }


  2091. #if (NGX_HTTP_CACHE)

  2093. static char *
  2094. ‌ngx_http_scgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2095. {
  2096.     ngx_http_scgi_loc_conf_t *scf = conf;

  2098.     ngx_str_t                         *value;
  2099.     ngx_http_complex_value_t           cv;
  2100.     ngx_http_compile_complex_value_t   ccv;

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

  2104.     if (scf->upstream.cache != NGX_CONF_UNSET) {
  2105.         return "is duplicate";
  2106.     }

  2108.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2109.         scf->upstream.cache = 0;
  2110.         return NGX_CONF_OK;
  2111.     }

  2113.     if (scf->upstream.store > 0) {
  2114.         return "is incompatible with \"scgi_store\"";
  2115.     }

  2117.     scf->upstream.cache = 1;

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

  2121.     ccv.cf = cf;
  2122.     ccv.value = &value[1];
  2123.     ccv.complex_value = &cv;

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

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

  2131.         scf->upstream.cache_value = ngx_palloc(cf->pool,
  2132.                                              sizeof(ngx_http_complex_value_t));
  2133.         if (scf->upstream.cache_value == NULL) {
  2134.             return NGX_CONF_ERROR;
  2135.         }

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

  2139.         return NGX_CONF_OK;
  2140.     }

  2142.     scf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2143.                                                      &ngx_http_scgi_module);
  2144.     if (scf->upstream.cache_zone == NULL) {
  2145.         return NGX_CONF_ERROR;
  2146.     }

  2148.     return NGX_CONF_OK;
  2149. }


  2152. static char *
  2153. ‌ngx_http_scgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2154. {
  2155.     ngx_http_scgi_loc_conf_t *scf = conf;

  2157.     ngx_str_t                         *value;
  2158.     ngx_http_compile_complex_value_t   ccv;

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

  2162.     if (scf->cache_key.value.data) {
  2163.         return "is duplicate";
  2164.     }

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

  2168.     ccv.cf = cf;
  2169.     ccv.value = &value[1];
  2170.     ccv.complex_value = &scf->cache_key;

  2172.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2173.         return NGX_CONF_ERROR;
  2174.     }

  2176.     return NGX_CONF_OK;
  2177. }

  2179. #endif

One Level Up Top Level