One Level Up Top Level

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

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. #if (NGX_HTTP_CACHE)

  458. ‌static ngx_keyval_t  ngx_http_scgi_cache_headers[] = {
  459.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  460.       ngx_string("$upstream_cache_last_modified") },
  461.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  462.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  463.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  464.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  465.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  466.     { ngx_null_string, ngx_null_string }
  467. };

  469. #endif


  472. ‌static ngx_path_init_t ngx_http_scgi_temp_path = {
  473.     ngx_string(NGX_HTTP_SCGI_TEMP_PATH), { 1, 2, 0 }
  474. };


  477. static ngx_int_t
  478. ‌ngx_http_scgi_handler(ngx_http_request_t *r)
  479. {
  480.     ngx_int_t                   rc;
  481.     ngx_http_status_t          *status;
  482.     ngx_http_upstream_t        *u;
  483.     ngx_http_scgi_loc_conf_t   *scf;
  484. #if (NGX_HTTP_CACHE)
  485.     ngx_http_scgi_main_conf_t  *smcf;
  486. #endif

  488.     if (ngx_http_upstream_create(r) != NGX_OK) {
  489.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  490.     }

  492.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  493.     if (status == NULL) {
  494.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  495.     }

  497.     ngx_http_set_ctx(r, status, ngx_http_scgi_module);

  499.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  501.     if (scf->scgi_lengths) {
  502.         if (ngx_http_scgi_eval(r, scf) != NGX_OK) {
  503.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  504.         }
  505.     }

  507.     u = r->upstream;

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

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

  514. #if (NGX_HTTP_CACHE)
  515.     smcf = ngx_http_get_module_main_conf(r, ngx_http_scgi_module);

  517.     u->caches = &smcf->caches;
  518.     u->create_key = ngx_http_scgi_create_key;
  519. #endif

  521.     u->create_request = ngx_http_scgi_create_request;
  522.     u->reinit_request = ngx_http_scgi_reinit_request;
  523.     u->process_header = ngx_http_scgi_process_status_line;
  524.     u->abort_request = ngx_http_scgi_abort_request;
  525.     u->finalize_request = ngx_http_scgi_finalize_request;
  526.     r->state = 0;

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

  530.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  531.     if (u->pipe == NULL) {
  532.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  533.     }

  535.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  536.     u->pipe->input_ctx = r;

  538.     u->input_filter_init = ngx_http_scgi_input_filter_init;
  539.     u->input_filter = ngx_http_upstream_non_buffered_filter;
  540.     u->input_filter_ctx = r;

  542.     if (!scf->upstream.request_buffering
  543.         && scf->upstream.pass_request_body
  544.         && !r->headers_in.chunked)
  545.     {
  546.         r->request_body_no_buffering = 1;
  547.     }

  549.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  551.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  552.         return rc;
  553.     }

  555.     return NGX_DONE;
  556. }


  559. static ngx_int_t
  560. ‌ngx_http_scgi_eval(ngx_http_request_t *r, ngx_http_scgi_loc_conf_t * scf)
  561. {
  562.     ngx_url_t             url;
  563.     ngx_http_upstream_t  *u;

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

  567.     if (ngx_http_script_run(r, &url.url, scf->scgi_lengths->elts, 0,
  568.                             scf->scgi_values->elts)
  569.         == NULL)
  570.     {
  571.         return NGX_ERROR;
  572.     }

  574.     url.no_resolve = 1;

  576.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  577.         if (url.err) {
  578.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  579.                           "%s in upstream \"%V\"", url.err, &url.url);
  580.         }

  582.         return NGX_ERROR;
  583.     }

  585.     u = r->upstream;

  587.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  588.     if (u->resolved == NULL) {
  589.         return NGX_ERROR;
  590.     }

  592.     if (url.addrs) {
  593.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  594.         u->resolved->socklen = url.addrs[0].socklen;
  595.         u->resolved->name = url.addrs[0].name;
  596.         u->resolved->naddrs = 1;
  597.     }

  599.     u->resolved->host = url.host;
  600.     u->resolved->port = url.port;
  601.     u->resolved->no_port = url.no_port;

  603.     return NGX_OK;
  604. }


  607. #if (NGX_HTTP_CACHE)

  609. static ngx_int_t
  610. ‌ngx_http_scgi_create_key(ngx_http_request_t *r)
  611. {
  612.     ngx_str_t                 *key;
  613.     ngx_http_scgi_loc_conf_t  *scf;

  615.     key = ngx_array_push(&r->cache->keys);
  616.     if (key == NULL) {
  617.         return NGX_ERROR;
  618.     }

  620.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  622.     if (ngx_http_complex_value(r, &scf->cache_key, key) != NGX_OK) {
  623.         return NGX_ERROR;
  624.     }

  626.     return NGX_OK;
  627. }

  629. #endif


  632. static ngx_int_t
  633. ‌ngx_http_scgi_create_request(ngx_http_request_t *r)
  634. {
  635.     off_t                         content_length_n;
  636.     u_char                        ch, sep, *key, *val, *lowcase_key;
  637.     size_t                        len, key_len, val_len, allocated;
  638.     ngx_buf_t                    *b;
  639.     ngx_str_t                     content_length;
  640.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  641.     ngx_chain_t                  *cl, *body;
  642.     ngx_list_part_t              *part;
  643.     ngx_table_elt_t              *header, *hn, **ignored;
  644.     ngx_http_scgi_params_t       *params;
  645.     ngx_http_script_code_pt       code;
  646.     ngx_http_script_engine_t      e, le;
  647.     ngx_http_scgi_loc_conf_t     *scf;
  648.     ngx_http_script_len_code_pt   lcode;
  649.     u_char                        buffer[NGX_OFF_T_LEN];

  651.     content_length_n = 0;
  652.     body = r->upstream->request_bufs;

  654.     while (body) {
  655.         content_length_n += ngx_buf_size(body->buf);
  656.         body = body->next;
  657.     }

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

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

  664.     header_params = 0;
  665.     ignored = NULL;

  667.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  669. #if (NGX_HTTP_CACHE)
  670.     params = r->upstream->cacheable ? &scf->params_cache : &scf->params;
  671. #else
  672.     params = &scf->params;
  673. #endif

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

  678.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  679.         le.flushed = 1;

  681.         le.ip = params->lengths->elts;
  682.         le.request = r;

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

  686.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  687.             key_len = lcode(&le);

  689.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  690.             skip_empty = lcode(&le);

  692.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  693.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  694.             }
  695.             le.ip += sizeof(uintptr_t);

  697.             if (skip_empty && val_len == 0) {
  698.                 continue;
  699.             }

  701.             len += key_len + val_len + 1;
  702.         }
  703.     }

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

  707.         allocated = 0;
  708.         lowcase_key = NULL;

  710.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  711.             return NGX_ERROR;
  712.         }

  714.         if (params->number || r->headers_in.multi) {
  715.             n = 0;
  716.             part = &r->headers_in.headers.part;

  718.             while (part) {
  719.                 n += part->nelts;
  720.                 part = part->next;
  721.             }

  723.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  724.             if (ignored == NULL) {
  725.                 return NGX_ERROR;
  726.             }
  727.         }

  729.         part = &r->headers_in.headers.part;
  730.         header = part->elts;

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

  734.             if (i >= part->nelts) {
  735.                 if (part->next == NULL) {
  736.                     break;
  737.                 }

  739.                 part = part->next;
  740.                 header = part->elts;
  741.                 i = 0;
  742.             }

  744.             for (n = 0; n < header_params; n++) {
  745.                 if (&header[i] == ignored[n]) {
  746.                     goto next_length;
  747.                 }
  748.             }

  750.             if (params->number) {
  751.                 if (allocated < header[i].key.len) {
  752.                     allocated = header[i].key.len + 16;
  753.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  754.                     if (lowcase_key == NULL) {
  755.                         return NGX_ERROR;
  756.                     }
  757.                 }

  759.                 hash = 0;

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

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

  767.                     } else if (ch == '-') {
  768.                         ch = '_';
  769.                     }

  771.                     hash = ngx_hash(hash, ch);
  772.                     lowcase_key[n] = ch;
  773.                 }

  775.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  776.                     ignored[header_params++] = &header[i];
  777.                     continue;
  778.                 }
  779.             }

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

  784.             for (hn = header[i].next; hn; hn = hn->next) {
  785.                 len += hn->value.len + 2;
  786.                 ignored[header_params++] = hn;
  787.             }

  789.         next_length:

  791.             continue;
  792.         }
  793.     }

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

  797.     b = ngx_create_temp_buf(r->pool, NGX_SIZE_T_LEN + 1 + len + 1);
  798.     if (b == NULL) {
  799.         return NGX_ERROR;
  800.     }

  802.     cl = ngx_alloc_chain_link(r->pool);
  803.     if (cl == NULL) {
  804.         return NGX_ERROR;
  805.     }

  807.     cl->buf = b;

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

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

  815.         e.ip = params->values->elts;
  816.         e.pos = b->last;
  817.         e.request = r;
  818.         e.flushed = 1;

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

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

  824.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  825.             lcode(&le); /* key length */

  827.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  828.             skip_empty = lcode(&le);

  830.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  831.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  832.             }
  833.             le.ip += sizeof(uintptr_t);

  835.             if (skip_empty && val_len == 0) {
  836.                 e.skip = 1;

  838.                 while (*(uintptr_t *) e.ip) {
  839.                     code = *(ngx_http_script_code_pt *) e.ip;
  840.                     code((ngx_http_script_engine_t *) &e);
  841.                 }
  842.                 e.ip += sizeof(uintptr_t);

  844.                 e.skip = 0;

  846.                 continue;
  847.             }

  849. #if (NGX_DEBUG)
  850.             key = e.pos;
  851. #endif
  852.             code = *(ngx_http_script_code_pt *) e.ip;
  853.             code((ngx_http_script_engine_t *) &e);

  855. #if (NGX_DEBUG)
  856.             val = e.pos;
  857. #endif
  858.             while (*(uintptr_t *) e.ip) {
  859.                 code = *(ngx_http_script_code_pt *) e.ip;
  860.                 code((ngx_http_script_engine_t *) &e);
  861.             }
  862.             *e.pos++ = '\0';
  863.             e.ip += sizeof(uintptr_t);

  865.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  866.                            "scgi param: \"%s: %s\"", key, val);
  867.         }

  869.         b->last = e.pos;
  870.     }

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

  874.         part = &r->headers_in.headers.part;
  875.         header = part->elts;

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

  879.             if (i >= part->nelts) {
  880.                 if (part->next == NULL) {
  881.                     break;
  882.                 }

  884.                 part = part->next;
  885.                 header = part->elts;
  886.                 i = 0;
  887.             }

  889.             for (n = 0; n < header_params; n++) {
  890.                 if (&header[i] == ignored[n]) {
  891.                     goto next_value;
  892.                 }
  893.             }

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

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

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

  904.                 } else if (ch == '-') {
  905.                     ch = '_';
  906.                 }

  908.                 *b->last++ = ch;
  909.             }

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

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

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

  918.                 if (header[i].key.len == sizeof("Cookie") - 1
  919.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  920.                                        sizeof("Cookie") - 1)
  921.                        == 0)
  922.                 {
  923.                     sep = ';';

  925.                 } else {
  926.                     sep = ',';
  927.                 }

  929.                 for (hn = header[i].next; hn; hn = hn->next) {
  930.                     *b->last++ = sep;
  931.                     *b->last++ = ' ';
  932.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  933.                 }
  934.             }

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

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

  941.         next_value:

  943.             continue;
  944.         }
  945.     }

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

  949.     if (r->request_body_no_buffering) {
  950.         r->upstream->request_bufs = cl;

  952.     } else if (scf->upstream.pass_request_body) {
  953.         body = r->upstream->request_bufs;
  954.         r->upstream->request_bufs = cl;

  956.         while (body) {
  957.             b = ngx_alloc_buf(r->pool);
  958.             if (b == NULL) {
  959.                 return NGX_ERROR;
  960.             }

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

  964.             cl->next = ngx_alloc_chain_link(r->pool);
  965.             if (cl->next == NULL) {
  966.                 return NGX_ERROR;
  967.             }

  969.             cl = cl->next;
  970.             cl->buf = b;

  972.             body = body->next;
  973.         }

  975.     } else {
  976.         r->upstream->request_bufs = cl;
  977.     }

  979.     cl->next = NULL;

  981.     return NGX_OK;
  982. }


  985. static ngx_int_t
  986. ‌ngx_http_scgi_reinit_request(ngx_http_request_t *r)
  987. {
  988.     ngx_http_status_t  *status;

  990.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  992.     if (status == NULL) {
  993.         return NGX_OK;
  994.     }

  996.     status->code = 0;
  997.     status->count = 0;
  998.     status->start = NULL;
  999.     status->end = NULL;

  1001.     r->upstream->process_header = ngx_http_scgi_process_status_line;
  1002.     r->state = 0;

  1004.     return NGX_OK;
  1005. }


  1008. static ngx_int_t
  1009. ‌ngx_http_scgi_process_status_line(ngx_http_request_t *r)
  1010. {
  1011.     size_t                len;
  1012.     ngx_int_t             rc;
  1013.     ngx_http_status_t    *status;
  1014.     ngx_http_upstream_t  *u;

  1016.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  1018.     if (status == NULL) {
  1019.         return NGX_ERROR;
  1020.     }

  1022.     u = r->upstream;

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

  1026.     if (rc == NGX_AGAIN) {
  1027.         return rc;
  1028.     }

  1030.     if (rc == NGX_ERROR) {
  1031.         u->process_header = ngx_http_scgi_process_header;
  1032.         return ngx_http_scgi_process_header(r);
  1033.     }

  1035.     if (u->state && u->state->status == 0) {
  1036.         u->state->status = status->code;
  1037.     }

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

  1041.     len = status->end - status->start;
  1042.     u->headers_in.status_line.len = len;

  1044.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1045.     if (u->headers_in.status_line.data == NULL) {
  1046.         return NGX_ERROR;
  1047.     }

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

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

  1055.     u->process_header = ngx_http_scgi_process_header;

  1057.     return ngx_http_scgi_process_header(r);
  1058. }


  1061. static ngx_int_t
  1062. ‌ngx_http_scgi_process_header(ngx_http_request_t *r)
  1063. {
  1064.     ngx_str_t                      *status_line;
  1065.     ngx_int_t                       rc, status;
  1066.     ngx_table_elt_t                *h;
  1067.     ngx_http_upstream_t            *u;
  1068.     ngx_http_upstream_header_t     *hh;
  1069.     ngx_http_upstream_main_conf_t  *umcf;

  1071.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1073.     for ( ;; ) {

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

  1077.         if (rc == NGX_OK) {

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

  1081.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1082.             if (h == NULL) {
  1083.                 return NGX_ERROR;
  1084.             }

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

  1088.             h->key.len = r->header_name_end - r->header_name_start;
  1089.             h->value.len = r->header_end - r->header_start;

  1091.             h->key.data = ngx_pnalloc(r->pool,
  1092.                                       h->key.len + 1 + h->value.len + 1
  1093.                                       + h->key.len);
  1094.             if (h->key.data == NULL) {
  1095.                 h->hash = 0;
  1096.                 return NGX_ERROR;
  1097.             }

  1099.             h->value.data = h->key.data + h->key.len + 1;
  1100.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1102.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1103.             h->key.data[h->key.len] = '\0';
  1104.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1105.             h->value.data[h->value.len] = '\0';

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

  1110.             } else {
  1111.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1112.             }

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

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

  1120.                 if (rc != NGX_OK) {
  1121.                     return rc;
  1122.                 }
  1123.             }

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

  1128.             continue;
  1129.         }

  1131.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1138.             u = r->upstream;

  1140.             if (u->headers_in.status_n) {
  1141.                 goto done;
  1142.             }

  1144.             if (u->headers_in.status) {
  1145.                 status_line = &u->headers_in.status->value;

  1147.                 status = ngx_atoi(status_line->data, 3);
  1148.                 if (status == NGX_ERROR) {
  1149.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1150.                                   "upstream sent invalid status \"%V\"",
  1151.                                   status_line);
  1152.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1153.                 }

  1155.                 u->headers_in.status_n = status;

  1157.                 if (status_line->len > 3) {
  1158.                     u->headers_in.status_line = *status_line;
  1159.                 }

  1161.             } else if (u->headers_in.location) {
  1162.                 u->headers_in.status_n = 302;
  1163.                 ngx_str_set(&u->headers_in.status_line,
  1164.                             "302 Moved Temporarily");

  1166.             } else {
  1167.                 u->headers_in.status_n = 200;
  1168.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1169.             }

  1171.             if (u->state && u->state->status == 0) {
  1172.                 u->state->status = u->headers_in.status_n;
  1173.             }

  1175.         done:

  1177.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1178.                 && r->headers_in.upgrade)
  1179.             {
  1180.                 u->upgrade = 1;
  1181.             }

  1183.             return NGX_OK;
  1184.         }

  1186.         if (rc == NGX_AGAIN) {
  1187.             return NGX_AGAIN;
  1188.         }

  1190.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1192.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1193.                       "upstream sent invalid header: \"%*s\\x%02xd...\"",
  1194.                       r->header_end - r->header_name_start,
  1195.                       r->header_name_start, *r->header_end);

  1197.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1198.     }
  1199. }


  1202. static ngx_int_t
  1203. ‌ngx_http_scgi_input_filter_init(void *data)
  1204. {
  1205.     ngx_http_request_t   *r = data;
  1206.     ngx_http_upstream_t  *u;

  1208.     u = r->upstream;

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

  1214.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1215.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  1216.     {
  1217.         u->pipe->length = 0;
  1218.         u->length = 0;

  1220.     } else if (r->method == NGX_HTTP_HEAD) {
  1221.         u->pipe->length = -1;
  1222.         u->length = -1;

  1224.     } else {
  1225.         u->pipe->length = u->headers_in.content_length_n;
  1226.         u->length = u->headers_in.content_length_n;
  1227.     }

  1229.     return NGX_OK;
  1230. }


  1233. static void
  1234. ‌ngx_http_scgi_abort_request(ngx_http_request_t *r)
  1235. {
  1236.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1237.                    "abort http scgi request");

  1239.     return;
  1240. }


  1243. static void
  1244. ‌ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1245. {
  1246.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1247.                    "finalize http scgi request");

  1249.     return;
  1250. }


  1253. static void *
  1254. ‌ngx_http_scgi_create_main_conf(ngx_conf_t *cf)
  1255. {
  1256.     ngx_http_scgi_main_conf_t  *conf;

  1258.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_main_conf_t));
  1259.     if (conf == NULL) {
  1260.         return NULL;
  1261.     }

  1263. #if (NGX_HTTP_CACHE)
  1264.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1265.                        sizeof(ngx_http_file_cache_t *))
  1266.         != NGX_OK)
  1267.     {
  1268.         return NULL;
  1269.     }
  1270. #endif

  1272.     return conf;
  1273. }


  1276. static void *
  1277. ‌ngx_http_scgi_create_loc_conf(ngx_conf_t *cf)
  1278. {
  1279.     ngx_http_scgi_loc_conf_t  *conf;

  1281.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_loc_conf_t));
  1282.     if (conf == NULL) {
  1283.         return NULL;
  1284.     }

  1286.     /*
  1287.      * set by ngx_pcalloc():
  1288.      *
  1289.      *     conf->upstream.bufs.num = 0;
  1290.      *     conf->upstream.ignore_headers = 0;
  1291.      *     conf->upstream.next_upstream = 0;
  1292.      *     conf->upstream.cache_zone = NULL;
  1293.      *     conf->upstream.cache_use_stale = 0;
  1294.      *     conf->upstream.cache_methods = 0;
  1295.      *     conf->upstream.temp_path = NULL;
  1296.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  1297.      *     conf->upstream.store_lengths = NULL;
  1298.      *     conf->upstream.store_values = NULL;
  1299.      */

  1301.     conf->upstream.store = NGX_CONF_UNSET;
  1302.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1303.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1304.     conf->upstream.buffering = NGX_CONF_UNSET;
  1305.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  1306.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1307.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1309.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  1310.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;

  1312.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1313.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1314.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1315.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1317.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1318.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1319.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  1321.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1322.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1323.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1325.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1326.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1328. #if (NGX_HTTP_CACHE)
  1329.     conf->upstream.cache = NGX_CONF_UNSET;
  1330.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1331.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  1332.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1333.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1334.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1335.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1336.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1337.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1338.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1339.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  1340. #endif

  1342.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1343.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1345.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1347.     /* "scgi_cyclic_temp_file" is disabled */
  1348.     conf->upstream.cyclic_temp_file = 0;

  1350.     conf->upstream.change_buffering = 1;

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

  1354.     return conf;
  1355. }


  1358. static char *
  1359. ‌ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1360. {
  1361.     ngx_http_scgi_loc_conf_t *prev = parent;
  1362.     ngx_http_scgi_loc_conf_t *conf = child;

  1364.     size_t                        size;
  1365.     ngx_int_t                     rc;
  1366.     ngx_hash_init_t               hash;
  1367.     ngx_http_core_loc_conf_t     *clcf;

  1369. #if (NGX_HTTP_CACHE)

  1371.     if (conf->upstream.store > 0) {
  1372.         conf->upstream.cache = 0;
  1373.     }

  1375.     if (conf->upstream.cache > 0) {
  1376.         conf->upstream.store = 0;
  1377.     }

  1379. #endif

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

  1384.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1385.         conf->upstream.store_values = prev->upstream.store_values;
  1386.     }

  1388.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1389.                               prev->upstream.store_access, 0600);

  1391.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1392.                               prev->upstream.next_upstream_tries, 0);

  1394.     ngx_conf_merge_value(conf->upstream.buffering,
  1395.                               prev->upstream.buffering, 1);

  1397.     ngx_conf_merge_value(conf->upstream.request_buffering,
  1398.                               prev->upstream.request_buffering, 1);

  1400.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1401.                               prev->upstream.ignore_client_abort, 0);

  1403.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1404.                               prev->upstream.force_ranges, 0);

  1406.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1407.                               prev->upstream.local, NULL);

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

  1412.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1413.                               prev->upstream.connect_timeout, 60000);

  1415.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1416.                               prev->upstream.send_timeout, 60000);

  1418.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1419.                               prev->upstream.read_timeout, 60000);

  1421.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1422.                               prev->upstream.next_upstream_timeout, 0);

  1424.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1425.                               prev->upstream.send_lowat, 0);

  1427.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1428.                               prev->upstream.buffer_size,
  1429.                               (size_t) ngx_pagesize);

  1431.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  1432.                               prev->upstream.limit_rate, NULL);


  1435.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1436.                               8, ngx_pagesize);

  1438.     if (conf->upstream.bufs.num < 2) {
  1439.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1440.                            "there must be at least 2 \"scgi_buffers\"");
  1441.         return NGX_CONF_ERROR;
  1442.     }


  1445.     size = conf->upstream.buffer_size;
  1446.     if (size < conf->upstream.bufs.size) {
  1447.         size = conf->upstream.bufs.size;
  1448.     }


  1451.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1452.                               prev->upstream.busy_buffers_size_conf,
  1453.                               NGX_CONF_UNSET_SIZE);

  1455.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1456.         conf->upstream.busy_buffers_size = 2 * size;
  1457.     } else {
  1458.         conf->upstream.busy_buffers_size =
  1459.             conf->upstream.busy_buffers_size_conf;
  1460.     }

  1462.     if (conf->upstream.busy_buffers_size < size) {
  1463.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1464.             "\"scgi_busy_buffers_size\" must be equal to or greater "
  1465.             "than the maximum of the value of \"scgi_buffer_size\" and "
  1466.             "one of the \"scgi_buffers\"");

  1468.         return NGX_CONF_ERROR;
  1469.     }

  1471.     if (conf->upstream.busy_buffers_size
  1472.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1473.     {
  1474.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1475.             "\"scgi_busy_buffers_size\" must be less than "
  1476.             "the size of all \"scgi_buffers\" minus one buffer");

  1478.         return NGX_CONF_ERROR;
  1479.     }


  1482.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1483.                               prev->upstream.temp_file_write_size_conf,
  1484.                               NGX_CONF_UNSET_SIZE);

  1486.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1487.         conf->upstream.temp_file_write_size = 2 * size;
  1488.     } else {
  1489.         conf->upstream.temp_file_write_size =
  1490.             conf->upstream.temp_file_write_size_conf;
  1491.     }

  1493.     if (conf->upstream.temp_file_write_size < size) {
  1494.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1495.             "\"scgi_temp_file_write_size\" must be equal to or greater than "
  1496.             "the maximum of the value of \"scgi_buffer_size\" and "
  1497.             "one of the \"scgi_buffers\"");

  1499.         return NGX_CONF_ERROR;
  1500.     }


  1503.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1504.                               prev->upstream.max_temp_file_size_conf,
  1505.                               NGX_CONF_UNSET_SIZE);

  1507.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1508.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1509.     } else {
  1510.         conf->upstream.max_temp_file_size =
  1511.             conf->upstream.max_temp_file_size_conf;
  1512.     }

  1514.     if (conf->upstream.max_temp_file_size != 0
  1515.         && conf->upstream.max_temp_file_size < size)
  1516.     {
  1517.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1518.             "\"scgi_max_temp_file_size\" must be equal to zero to disable "
  1519.             "temporary files usage or must be equal to or greater than "
  1520.             "the maximum of the value of \"scgi_buffer_size\" and "
  1521.             "one of the \"scgi_buffers\"");

  1523.         return NGX_CONF_ERROR;
  1524.     }


  1527.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1528.                                  prev->upstream.ignore_headers,
  1529.                                  NGX_CONF_BITMASK_SET);


  1532.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1533.                                  prev->upstream.next_upstream,
  1534.                                  (NGX_CONF_BITMASK_SET
  1535.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1536.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1538.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1539.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1540.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1541.     }

  1543.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1544.                                   prev->upstream.temp_path,
  1545.                                   &ngx_http_scgi_temp_path)
  1546.         != NGX_OK)
  1547.     {
  1548.         return NGX_CONF_ERROR;
  1549.     }

  1551. #if (NGX_HTTP_CACHE)

  1553.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1554.         ngx_conf_merge_value(conf->upstream.cache,
  1555.                               prev->upstream.cache, 0);

  1557.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1558.         conf->upstream.cache_value = prev->upstream.cache_value;
  1559.     }

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

  1564.         shm_zone = conf->upstream.cache_zone;

  1566.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1567.                            "\"scgi_cache\" zone \"%V\" is unknown",
  1568.                            &shm_zone->shm.name);

  1570.         return NGX_CONF_ERROR;
  1571.     }

  1573.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1574.                               prev->upstream.cache_min_uses, 1);

  1576.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  1577.                               prev->upstream.cache_max_range_offset,
  1578.                               NGX_MAX_OFF_T_VALUE);

  1580.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1581.                               prev->upstream.cache_use_stale,
  1582.                               (NGX_CONF_BITMASK_SET
  1583.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1585.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1586.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1587.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1588.     }

  1590.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1591.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1592.     }

  1594.     if (conf->upstream.cache_methods == 0) {
  1595.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1596.     }

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

  1600.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1601.                              prev->upstream.cache_bypass, NULL);

  1603.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1604.                              prev->upstream.no_cache, NULL);

  1606.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1607.                              prev->upstream.cache_valid, NULL);

  1609.     if (conf->cache_key.value.data == NULL) {
  1610.         conf->cache_key = prev->cache_key;
  1611.     }

  1613.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1614.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1615.                            "no \"scgi_cache_key\" for \"scgi_cache\"");
  1616.     }

  1618.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1619.                               prev->upstream.cache_lock, 0);

  1621.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1622.                               prev->upstream.cache_lock_timeout, 5000);

  1624.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1625.                               prev->upstream.cache_lock_age, 5000);

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

  1630.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  1631.                               prev->upstream.cache_background_update, 0);

  1633. #endif

  1635.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1636.                          prev->upstream.pass_request_headers, 1);
  1637.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1638.                          prev->upstream.pass_request_body, 1);

  1640.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1641.                          prev->upstream.intercept_errors, 0);

  1643.     hash.max_size = 512;
  1644.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1645.     hash.name = "scgi_hide_headers_hash";

  1647.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1648.             &prev->upstream, ngx_http_scgi_hide_headers, &hash)
  1649.         != NGX_OK)
  1650.     {
  1651.         return NGX_CONF_ERROR;
  1652.     }

  1654.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1656.     if (clcf->noname
  1657.         && conf->upstream.upstream == NULL && conf->scgi_lengths == NULL)
  1658.     {
  1659.         conf->upstream.upstream = prev->upstream.upstream;
  1660.         conf->scgi_lengths = prev->scgi_lengths;
  1661.         conf->scgi_values = prev->scgi_values;
  1662.     }

  1664.     if (clcf->lmt_excpt && clcf->handler == NULL
  1665.         && (conf->upstream.upstream || conf->scgi_lengths))
  1666.     {
  1667.         clcf->handler = ngx_http_scgi_handler;
  1668.     }

  1670.     if (conf->params_source == NULL) {
  1671.         conf->params = prev->params;
  1672. #if (NGX_HTTP_CACHE)
  1673.         conf->params_cache = prev->params_cache;
  1674. #endif
  1675.         conf->params_source = prev->params_source;
  1676.     }

  1678.     rc = ngx_http_scgi_init_params(cf, conf, &conf->params, NULL);
  1679.     if (rc != NGX_OK) {
  1680.         return NGX_CONF_ERROR;
  1681.     }

  1683. #if (NGX_HTTP_CACHE)

  1685.     if (conf->upstream.cache) {
  1686.         rc = ngx_http_scgi_init_params(cf, conf, &conf->params_cache,
  1687.                                        ngx_http_scgi_cache_headers);
  1688.         if (rc != NGX_OK) {
  1689.             return NGX_CONF_ERROR;
  1690.         }
  1691.     }

  1693. #endif

  1695.     /*
  1696.      * special handling to preserve conf->params in the "http" section
  1697.      * to inherit it to all servers
  1698.      */

  1700.     if (prev->params.hash.buckets == NULL
  1701.         && conf->params_source == prev->params_source)
  1702.     {
  1703.         prev->params = conf->params;
  1704. #if (NGX_HTTP_CACHE)
  1705.         prev->params_cache = conf->params_cache;
  1706. #endif
  1707.     }

  1709.     return NGX_CONF_OK;
  1710. }


  1713. static ngx_int_t
  1714. ‌ngx_http_scgi_init_params(ngx_conf_t *cf, ngx_http_scgi_loc_conf_t *conf,
  1715.     ngx_http_scgi_params_t *params, ngx_keyval_t *default_params)
  1716. {
  1717.     u_char                       *p;
  1718.     size_t                        size;
  1719.     uintptr_t                    *code;
  1720.     ngx_uint_t                    i, nsrc;
  1721.     ngx_array_t                   headers_names, params_merged;
  1722.     ngx_keyval_t                 *h;
  1723.     ngx_hash_key_t               *hk;
  1724.     ngx_hash_init_t               hash;
  1725.     ngx_http_upstream_param_t    *src, *s;
  1726.     ngx_http_script_compile_t     sc;
  1727.     ngx_http_script_copy_code_t  *copy;

  1729.     if (params->hash.buckets) {
  1730.         return NGX_OK;
  1731.     }

  1733.     if (conf->params_source == NULL && default_params == NULL) {
  1734.         params->hash.buckets = (void *) 1;
  1735.         return NGX_OK;
  1736.     }

  1738.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  1739.     if (params->lengths == NULL) {
  1740.         return NGX_ERROR;
  1741.     }

  1743.     params->values = ngx_array_create(cf->pool, 512, 1);
  1744.     if (params->values == NULL) {
  1745.         return NGX_ERROR;
  1746.     }

  1748.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  1749.         != NGX_OK)
  1750.     {
  1751.         return NGX_ERROR;
  1752.     }

  1754.     if (conf->params_source) {
  1755.         src = conf->params_source->elts;
  1756.         nsrc = conf->params_source->nelts;

  1758.     } else {
  1759.         src = NULL;
  1760.         nsrc = 0;
  1761.     }

  1763.     if (default_params) {
  1764.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  1765.                            sizeof(ngx_http_upstream_param_t))
  1766.             != NGX_OK)
  1767.         {
  1768.             return NGX_ERROR;
  1769.         }

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

  1773.             s = ngx_array_push(&params_merged);
  1774.             if (s == NULL) {
  1775.                 return NGX_ERROR;
  1776.             }

  1778.             *s = src[i];
  1779.         }

  1781.         h = default_params;

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

  1785.             src = params_merged.elts;
  1786.             nsrc = params_merged.nelts;

  1788.             for (i = 0; i < nsrc; i++) {
  1789.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  1790.                     goto next;
  1791.                 }
  1792.             }

  1794.             s = ngx_array_push(&params_merged);
  1795.             if (s == NULL) {
  1796.                 return NGX_ERROR;
  1797.             }

  1799.             s->key = h->key;
  1800.             s->value = h->value;
  1801.             s->skip_empty = 1;

  1803.         next:

  1805.             h++;
  1806.         }

  1808.         src = params_merged.elts;
  1809.         nsrc = params_merged.nelts;
  1810.     }

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

  1814.         if (src[i].key.len > sizeof("HTTP_") - 1
  1815.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  1816.         {
  1817.             hk = ngx_array_push(&headers_names);
  1818.             if (hk == NULL) {
  1819.                 return NGX_ERROR;
  1820.             }

  1822.             hk->key.len = src[i].key.len - 5;
  1823.             hk->key.data = src[i].key.data + 5;
  1824.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  1825.             hk->value = (void *) 1;

  1827.             if (src[i].value.len == 0) {
  1828.                 continue;
  1829.             }
  1830.         }

  1832.         copy = ngx_array_push_n(params->lengths,
  1833.                                 sizeof(ngx_http_script_copy_code_t));
  1834.         if (copy == NULL) {
  1835.             return NGX_ERROR;
  1836.         }

  1838.         copy->code = (ngx_http_script_code_pt) (void *)
  1839.                                                  ngx_http_script_copy_len_code;
  1840.         copy->len = src[i].key.len + 1;

  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].skip_empty;


  1853.         size = (sizeof(ngx_http_script_copy_code_t)
  1854.                 + src[i].key.len + 1 + sizeof(uintptr_t) - 1)
  1855.                & ~(sizeof(uintptr_t) - 1);

  1857.         copy = ngx_array_push_n(params->values, size);
  1858.         if (copy == NULL) {
  1859.             return NGX_ERROR;
  1860.         }

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

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


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

  1871.         sc.cf = cf;
  1872.         sc.source = &src[i].value;
  1873.         sc.flushes = &params->flushes;
  1874.         sc.lengths = &params->lengths;
  1875.         sc.values = &params->values;

  1877.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1878.             return NGX_ERROR;
  1879.         }

  1881.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1882.         if (code == NULL) {
  1883.             return NGX_ERROR;
  1884.         }

  1886.         *code = (uintptr_t) NULL;


  1889.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  1890.         if (code == NULL) {
  1891.             return NGX_ERROR;
  1892.         }

  1894.         *code = (uintptr_t) NULL;
  1895.     }

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

  1902.     *code = (uintptr_t) NULL;

  1904.     params->number = headers_names.nelts;

  1906.     hash.hash = &params->hash;
  1907.     hash.key = ngx_hash_key_lc;
  1908.     hash.max_size = 512;
  1909.     hash.bucket_size = 64;
  1910.     hash.name = "scgi_params_hash";
  1911.     hash.pool = cf->pool;
  1912.     hash.temp_pool = NULL;

  1914.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  1915. }


  1918. static char *
  1919. ‌ngx_http_scgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1920. {
  1921.     ngx_http_scgi_loc_conf_t *scf = conf;

  1923.     ngx_url_t                   u;
  1924.     ngx_str_t                  *value, *url;
  1925.     ngx_uint_t                  n;
  1926.     ngx_http_core_loc_conf_t   *clcf;
  1927.     ngx_http_script_compile_t   sc;

  1929.     if (scf->upstream.upstream || scf->scgi_lengths) {
  1930.         return "is duplicate";
  1931.     }

  1933.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  1934.     clcf->handler = ngx_http_scgi_handler;

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

  1938.     url = &value[1];

  1940.     n = ngx_http_script_variables_count(url);

  1942.     if (n) {

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

  1946.         sc.cf = cf;
  1947.         sc.source = url;
  1948.         sc.lengths = &scf->scgi_lengths;
  1949.         sc.values = &scf->scgi_values;
  1950.         sc.variables = n;
  1951.         sc.complete_lengths = 1;
  1952.         sc.complete_values = 1;

  1954.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1955.             return NGX_CONF_ERROR;
  1956.         }

  1958.         return NGX_CONF_OK;
  1959.     }

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

  1963.     u.url = value[1];
  1964.     u.no_resolve = 1;

  1966.     scf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  1967.     if (scf->upstream.upstream == NULL) {
  1968.         return NGX_CONF_ERROR;
  1969.     }

  1971.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  1972.         clcf->auto_redirect = 1;
  1973.     }

  1975.     return NGX_CONF_OK;
  1976. }


  1979. static char *
  1980. ‌ngx_http_scgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1981. {
  1982.     ngx_http_scgi_loc_conf_t *scf = conf;

  1984.     ngx_str_t                  *value;
  1985.     ngx_http_script_compile_t   sc;

  1987.     if (scf->upstream.store != NGX_CONF_UNSET) {
  1988.         return "is duplicate";
  1989.     }

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

  1993.     if (ngx_strcmp(value[1].data, "off") == 0) {
  1994.         scf->upstream.store = 0;
  1995.         return NGX_CONF_OK;
  1996.     }

  1998.     if (value[1].len == 0) {
  1999.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  2000.         return NGX_CONF_ERROR;
  2001.     }

  2003. #if (NGX_HTTP_CACHE)
  2004.     if (scf->upstream.cache > 0) {
  2005.         return "is incompatible with \"scgi_cache\"";
  2006.     }
  2007. #endif

  2009.     scf->upstream.store = 1;

  2011.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2012.         return NGX_CONF_OK;
  2013.     }

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

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

  2020.     sc.cf = cf;
  2021.     sc.source = &value[1];
  2022.     sc.lengths = &scf->upstream.store_lengths;
  2023.     sc.values = &scf->upstream.store_values;
  2024.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2025.     sc.complete_lengths = 1;
  2026.     sc.complete_values = 1;

  2028.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2029.         return NGX_CONF_ERROR;
  2030.     }

  2032.     return NGX_CONF_OK;
  2033. }


  2036. #if (NGX_HTTP_CACHE)

  2038. static char *
  2039. ‌ngx_http_scgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2040. {
  2041.     ngx_http_scgi_loc_conf_t *scf = conf;

  2043.     ngx_str_t                         *value;
  2044.     ngx_http_complex_value_t           cv;
  2045.     ngx_http_compile_complex_value_t   ccv;

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

  2049.     if (scf->upstream.cache != NGX_CONF_UNSET) {
  2050.         return "is duplicate";
  2051.     }

  2053.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2054.         scf->upstream.cache = 0;
  2055.         return NGX_CONF_OK;
  2056.     }

  2058.     if (scf->upstream.store > 0) {
  2059.         return "is incompatible with \"scgi_store\"";
  2060.     }

  2062.     scf->upstream.cache = 1;

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

  2066.     ccv.cf = cf;
  2067.     ccv.value = &value[1];
  2068.     ccv.complex_value = &cv;

  2070.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2071.         return NGX_CONF_ERROR;
  2072.     }

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

  2076.         scf->upstream.cache_value = ngx_palloc(cf->pool,
  2077.                                              sizeof(ngx_http_complex_value_t));
  2078.         if (scf->upstream.cache_value == NULL) {
  2079.             return NGX_CONF_ERROR;
  2080.         }

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

  2084.         return NGX_CONF_OK;
  2085.     }

  2087.     scf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2088.                                                      &ngx_http_scgi_module);
  2089.     if (scf->upstream.cache_zone == NULL) {
  2090.         return NGX_CONF_ERROR;
  2091.     }

  2093.     return NGX_CONF_OK;
  2094. }


  2097. static char *
  2098. ‌ngx_http_scgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2099. {
  2100.     ngx_http_scgi_loc_conf_t *scf = conf;

  2102.     ngx_str_t                         *value;
  2103.     ngx_http_compile_complex_value_t   ccv;

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

  2107.     if (scf->cache_key.value.data) {
  2108.         return "is duplicate";
  2109.     }

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

  2113.     ccv.cf = cf;
  2114.     ccv.value = &value[1];
  2115.     ccv.complex_value = &scf->cache_key;

  2117.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2118.         return NGX_CONF_ERROR;
  2119.     }

  2121.     return NGX_CONF_OK;
  2122. }

  2124. #endif

One Level Up Top Level