One Level Up Top Level

src/http/modules/ngx_http_scgi_module.c - nginx-1.7.10

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 void ngx_http_scgi_abort_request(ngx_http_request_t *r);
  53. static void ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc);

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

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

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


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


  90. ‌ngx_module_t  ngx_http_scgi_module;


  93. ‌static ngx_command_t ngx_http_scgi_commands[] = {

  95.     { ngx_string("scgi_pass"),
  96.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  97.       ngx_http_scgi_pass,
  98.       NGX_HTTP_LOC_CONF_OFFSET,
  99.       0,
  100.       NULL },

  102.     { ngx_string("scgi_store"),
  103.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  104.       ngx_http_scgi_store,
  105.       NGX_HTTP_LOC_CONF_OFFSET,
  106.       0,
  107.       NULL },

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

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

  123.     { ngx_string("scgi_ignore_client_abort"),
  124.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  125.       ngx_conf_set_flag_slot,
  126.       NGX_HTTP_LOC_CONF_OFFSET,
  127.       offsetof(ngx_http_scgi_loc_conf_t, upstream.ignore_client_abort),
  128.       NULL },

  130.     { ngx_string("scgi_bind"),
  131.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  132.       ngx_http_upstream_bind_set_slot,
  133.       NGX_HTTP_LOC_CONF_OFFSET,
  134.       offsetof(ngx_http_scgi_loc_conf_t, upstream.local),
  135.       NULL },

  137.     { ngx_string("scgi_connect_timeout"),
  138.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  139.       ngx_conf_set_msec_slot,
  140.       NGX_HTTP_LOC_CONF_OFFSET,
  141.       offsetof(ngx_http_scgi_loc_conf_t, upstream.connect_timeout),
  142.       NULL },

  144.     { ngx_string("scgi_send_timeout"),
  145.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  146.       ngx_conf_set_msec_slot,
  147.       NGX_HTTP_LOC_CONF_OFFSET,
  148.       offsetof(ngx_http_scgi_loc_conf_t, upstream.send_timeout),
  149.       NULL },

  151.     { ngx_string("scgi_buffer_size"),
  152.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  153.       ngx_conf_set_size_slot,
  154.       NGX_HTTP_LOC_CONF_OFFSET,
  155.       offsetof(ngx_http_scgi_loc_conf_t, upstream.buffer_size),
  156.       NULL },

  158.     { ngx_string("scgi_pass_request_headers"),
  159.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  160.       ngx_conf_set_flag_slot,
  161.       NGX_HTTP_LOC_CONF_OFFSET,
  162.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_request_headers),
  163.       NULL },

  165.     { ngx_string("scgi_pass_request_body"),
  166.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  167.       ngx_conf_set_flag_slot,
  168.       NGX_HTTP_LOC_CONF_OFFSET,
  169.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_request_body),
  170.       NULL },

  172.     { ngx_string("scgi_intercept_errors"),
  173.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  174.       ngx_conf_set_flag_slot,
  175.       NGX_HTTP_LOC_CONF_OFFSET,
  176.       offsetof(ngx_http_scgi_loc_conf_t, upstream.intercept_errors),
  177.       NULL },

  179.     { ngx_string("scgi_read_timeout"),
  180.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  181.       ngx_conf_set_msec_slot,
  182.       NGX_HTTP_LOC_CONF_OFFSET,
  183.       offsetof(ngx_http_scgi_loc_conf_t, upstream.read_timeout),
  184.       NULL },

  186.     { ngx_string("scgi_buffers"),
  187.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  188.       ngx_conf_set_bufs_slot,
  189.       NGX_HTTP_LOC_CONF_OFFSET,
  190.       offsetof(ngx_http_scgi_loc_conf_t, upstream.bufs),
  191.       NULL },

  193.     { ngx_string("scgi_busy_buffers_size"),
  194.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  195.       ngx_conf_set_size_slot,
  196.       NGX_HTTP_LOC_CONF_OFFSET,
  197.       offsetof(ngx_http_scgi_loc_conf_t, upstream.busy_buffers_size_conf),
  198.       NULL },

  200.     { ngx_string("scgi_force_ranges"),
  201.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  202.       ngx_conf_set_flag_slot,
  203.       NGX_HTTP_LOC_CONF_OFFSET,
  204.       offsetof(ngx_http_scgi_loc_conf_t, upstream.force_ranges),
  205.       NULL },

  207.     { ngx_string("scgi_limit_rate"),
  208.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  209.       ngx_conf_set_size_slot,
  210.       NGX_HTTP_LOC_CONF_OFFSET,
  211.       offsetof(ngx_http_scgi_loc_conf_t, upstream.limit_rate),
  212.       NULL },

  214. #if (NGX_HTTP_CACHE)

  216.     { ngx_string("scgi_cache"),
  217.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  218.       ngx_http_scgi_cache,
  219.       NGX_HTTP_LOC_CONF_OFFSET,
  220.       0,
  221.       NULL },

  223.     { ngx_string("scgi_cache_key"),
  224.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  225.       ngx_http_scgi_cache_key,
  226.       NGX_HTTP_LOC_CONF_OFFSET,
  227.       0,
  228.       NULL },

  230.     { ngx_string("scgi_cache_path"),
  231.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  232.       ngx_http_file_cache_set_slot,
  233.       NGX_HTTP_MAIN_CONF_OFFSET,
  234.       offsetof(ngx_http_scgi_main_conf_t, caches),
  235.       &ngx_http_scgi_module },

  237.     { ngx_string("scgi_cache_bypass"),
  238.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  239.       ngx_http_set_predicate_slot,
  240.       NGX_HTTP_LOC_CONF_OFFSET,
  241.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_bypass),
  242.       NULL },

  244.     { ngx_string("scgi_no_cache"),
  245.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  246.       ngx_http_set_predicate_slot,
  247.       NGX_HTTP_LOC_CONF_OFFSET,
  248.       offsetof(ngx_http_scgi_loc_conf_t, upstream.no_cache),
  249.       NULL },

  251.     { ngx_string("scgi_cache_valid"),
  252.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  253.       ngx_http_file_cache_valid_set_slot,
  254.       NGX_HTTP_LOC_CONF_OFFSET,
  255.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_valid),
  256.       NULL },

  258.     { ngx_string("scgi_cache_min_uses"),
  259.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  260.       ngx_conf_set_num_slot,
  261.       NGX_HTTP_LOC_CONF_OFFSET,
  262.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_min_uses),
  263.       NULL },

  265.     { ngx_string("scgi_cache_use_stale"),
  266.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  267.       ngx_conf_set_bitmask_slot,
  268.       NGX_HTTP_LOC_CONF_OFFSET,
  269.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_use_stale),
  270.       &ngx_http_scgi_next_upstream_masks },

  272.     { ngx_string("scgi_cache_methods"),
  273.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  274.       ngx_conf_set_bitmask_slot,
  275.       NGX_HTTP_LOC_CONF_OFFSET,
  276.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_methods),
  277.       &ngx_http_upstream_cache_method_mask },

  279.     { ngx_string("scgi_cache_lock"),
  280.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  281.       ngx_conf_set_flag_slot,
  282.       NGX_HTTP_LOC_CONF_OFFSET,
  283.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock),
  284.       NULL },

  286.     { ngx_string("scgi_cache_lock_timeout"),
  287.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  288.       ngx_conf_set_msec_slot,
  289.       NGX_HTTP_LOC_CONF_OFFSET,
  290.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock_timeout),
  291.       NULL },

  293.     { ngx_string("scgi_cache_lock_age"),
  294.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  295.       ngx_conf_set_msec_slot,
  296.       NGX_HTTP_LOC_CONF_OFFSET,
  297.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_lock_age),
  298.       NULL },

  300.     { ngx_string("scgi_cache_revalidate"),
  301.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  302.       ngx_conf_set_flag_slot,
  303.       NGX_HTTP_LOC_CONF_OFFSET,
  304.       offsetof(ngx_http_scgi_loc_conf_t, upstream.cache_revalidate),
  305.       NULL },

  307. #endif

  309.     { ngx_string("scgi_temp_path"),
  310.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  311.       ngx_conf_set_path_slot,
  312.       NGX_HTTP_LOC_CONF_OFFSET,
  313.       offsetof(ngx_http_scgi_loc_conf_t, upstream.temp_path),
  314.       NULL },

  316.     { ngx_string("scgi_max_temp_file_size"),
  317.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  318.       ngx_conf_set_size_slot,
  319.       NGX_HTTP_LOC_CONF_OFFSET,
  320.       offsetof(ngx_http_scgi_loc_conf_t, upstream.max_temp_file_size_conf),
  321.       NULL },

  323.     { ngx_string("scgi_temp_file_write_size"),
  324.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  325.       ngx_conf_set_size_slot,
  326.       NGX_HTTP_LOC_CONF_OFFSET,
  327.       offsetof(ngx_http_scgi_loc_conf_t, upstream.temp_file_write_size_conf),
  328.       NULL },

  330.     { ngx_string("scgi_next_upstream"),
  331.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  332.       ngx_conf_set_bitmask_slot,
  333.       NGX_HTTP_LOC_CONF_OFFSET,
  334.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream),
  335.       &ngx_http_scgi_next_upstream_masks },

  337.     { ngx_string("scgi_next_upstream_tries"),
  338.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  339.       ngx_conf_set_num_slot,
  340.       NGX_HTTP_LOC_CONF_OFFSET,
  341.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream_tries),
  342.       NULL },

  344.     { ngx_string("scgi_next_upstream_timeout"),
  345.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  346.       ngx_conf_set_msec_slot,
  347.       NGX_HTTP_LOC_CONF_OFFSET,
  348.       offsetof(ngx_http_scgi_loc_conf_t, upstream.next_upstream_timeout),
  349.       NULL },

  351.     { ngx_string("scgi_param"),
  352.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  353.       ngx_http_upstream_param_set_slot,
  354.       NGX_HTTP_LOC_CONF_OFFSET,
  355.       offsetof(ngx_http_scgi_loc_conf_t, params_source),
  356.       NULL },

  358.     { ngx_string("scgi_pass_header"),
  359.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  360.       ngx_conf_set_str_array_slot,
  361.       NGX_HTTP_LOC_CONF_OFFSET,
  362.       offsetof(ngx_http_scgi_loc_conf_t, upstream.pass_headers),
  363.       NULL },

  365.     { ngx_string("scgi_hide_header"),
  366.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  367.       ngx_conf_set_str_array_slot,
  368.       NGX_HTTP_LOC_CONF_OFFSET,
  369.       offsetof(ngx_http_scgi_loc_conf_t, upstream.hide_headers),
  370.       NULL },

  372.     { ngx_string("scgi_ignore_headers"),
  373.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  374.       ngx_conf_set_bitmask_slot,
  375.       NGX_HTTP_LOC_CONF_OFFSET,
  376.       offsetof(ngx_http_scgi_loc_conf_t, upstream.ignore_headers),
  377.       &ngx_http_upstream_ignore_headers_masks },

  379.       ngx_null_command
  380. };


  383. ‌static ngx_http_module_t ngx_http_scgi_module_ctx = {
  384.     NULL,                                  /* preconfiguration */
  385.     NULL,                                  /* postconfiguration */

  387.     ngx_http_scgi_create_main_conf,        /* create main configuration */
  388.     NULL,                                  /* init main configuration */

  390.     NULL,                                  /* create server configuration */
  391.     NULL,                                  /* merge server configuration */

  393.     ngx_http_scgi_create_loc_conf,         /* create location configuration */
  394.     ngx_http_scgi_merge_loc_conf           /* merge location configuration */
  395. };


  398. ‌ngx_module_t ngx_http_scgi_module = {
  399.     NGX_MODULE_V1,
  400.     &ngx_http_scgi_module_ctx,             /* module context */
  401.     ngx_http_scgi_commands,                /* module directives */
  402.     NGX_HTTP_MODULE,                       /* module type */
  403.     NULL,                                  /* init master */
  404.     NULL,                                  /* init module */
  405.     NULL,                                  /* init process */
  406.     NULL,                                  /* init thread */
  407.     NULL,                                  /* exit thread */
  408.     NULL,                                  /* exit process */
  409.     NULL,                                  /* exit master */
  410.     NGX_MODULE_V1_PADDING
  411. };


  414. ‌static ngx_str_t ngx_http_scgi_hide_headers[] = {
  415.     ngx_string("Status"),
  416.     ngx_string("X-Accel-Expires"),
  417.     ngx_string("X-Accel-Redirect"),
  418.     ngx_string("X-Accel-Limit-Rate"),
  419.     ngx_string("X-Accel-Buffering"),
  420.     ngx_string("X-Accel-Charset"),
  421.     ngx_null_string
  422. };


  425. #if (NGX_HTTP_CACHE)

  427. ‌static ngx_keyval_t  ngx_http_scgi_cache_headers[] = {
  428.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  429.       ngx_string("$upstream_cache_last_modified") },
  430.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  431.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  432.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  433.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  434.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  435.     { ngx_null_string, ngx_null_string }
  436. };

  438. #endif


  441. ‌static ngx_path_init_t ngx_http_scgi_temp_path = {
  442.     ngx_string(NGX_HTTP_SCGI_TEMP_PATH), { 1, 2, 0 }
  443. };


  446. static ngx_int_t
  447. ‌ngx_http_scgi_handler(ngx_http_request_t *r)
  448. {
  449.     ngx_int_t                   rc;
  450.     ngx_http_status_t          *status;
  451.     ngx_http_upstream_t        *u;
  452.     ngx_http_scgi_loc_conf_t   *scf;
  453. #if (NGX_HTTP_CACHE)
  454.     ngx_http_scgi_main_conf_t  *smcf;
  455. #endif

  457.     if (ngx_http_upstream_create(r) != NGX_OK) {
  458.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  459.     }

  461.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  462.     if (status == NULL) {
  463.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  464.     }

  466.     ngx_http_set_ctx(r, status, ngx_http_scgi_module);

  468.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  470.     if (scf->scgi_lengths) {
  471.         if (ngx_http_scgi_eval(r, scf) != NGX_OK) {
  472.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  473.         }
  474.     }

  476.     u = r->upstream;

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

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

  483. #if (NGX_HTTP_CACHE)
  484.     smcf = ngx_http_get_module_main_conf(r, ngx_http_scgi_module);

  486.     u->caches = &smcf->caches;
  487.     u->create_key = ngx_http_scgi_create_key;
  488. #endif

  490.     u->create_request = ngx_http_scgi_create_request;
  491.     u->reinit_request = ngx_http_scgi_reinit_request;
  492.     u->process_header = ngx_http_scgi_process_status_line;
  493.     u->abort_request = ngx_http_scgi_abort_request;
  494.     u->finalize_request = ngx_http_scgi_finalize_request;
  495.     r->state = 0;

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

  499.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  500.     if (u->pipe == NULL) {
  501.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  502.     }

  504.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  505.     u->pipe->input_ctx = r;

  507.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  509.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  510.         return rc;
  511.     }

  513.     return NGX_DONE;
  514. }


  517. static ngx_int_t
  518. ‌ngx_http_scgi_eval(ngx_http_request_t *r, ngx_http_scgi_loc_conf_t * scf)
  519. {
  520.     ngx_url_t             url;
  521.     ngx_http_upstream_t  *u;

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

  525.     if (ngx_http_script_run(r, &url.url, scf->scgi_lengths->elts, 0,
  526.                             scf->scgi_values->elts)
  527.         == NULL)
  528.     {
  529.         return NGX_ERROR;
  530.     }

  532.     url.no_resolve = 1;

  534.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  535.         if (url.err) {
  536.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  537.                           "%s in upstream \"%V\"", url.err, &url.url);
  538.         }

  540.         return NGX_ERROR;
  541.     }

  543.     u = r->upstream;

  545.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  546.     if (u->resolved == NULL) {
  547.         return NGX_ERROR;
  548.     }

  550.     if (url.addrs && url.addrs[0].sockaddr) {
  551.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  552.         u->resolved->socklen = url.addrs[0].socklen;
  553.         u->resolved->naddrs = 1;
  554.         u->resolved->host = url.addrs[0].name;

  556.     } else {
  557.         u->resolved->host = url.host;
  558.         u->resolved->port = url.port;
  559.         u->resolved->no_port = url.no_port;
  560.     }

  562.     return NGX_OK;
  563. }


  566. #if (NGX_HTTP_CACHE)

  568. static ngx_int_t
  569. ‌ngx_http_scgi_create_key(ngx_http_request_t *r)
  570. {
  571.     ngx_str_t                 *key;
  572.     ngx_http_scgi_loc_conf_t  *scf;

  574.     key = ngx_array_push(&r->cache->keys);
  575.     if (key == NULL) {
  576.         return NGX_ERROR;
  577.     }

  579.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  581.     if (ngx_http_complex_value(r, &scf->cache_key, key) != NGX_OK) {
  582.         return NGX_ERROR;
  583.     }

  585.     return NGX_OK;
  586. }

  588. #endif


  591. static ngx_int_t
  592. ‌ngx_http_scgi_create_request(ngx_http_request_t *r)
  593. {
  594.     off_t                         content_length_n;
  595.     u_char                        ch, *key, *val, *lowcase_key;
  596.     size_t                        len, key_len, val_len, allocated;
  597.     ngx_buf_t                    *b;
  598.     ngx_str_t                     content_length;
  599.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  600.     ngx_chain_t                  *cl, *body;
  601.     ngx_list_part_t              *part;
  602.     ngx_table_elt_t              *header, **ignored;
  603.     ngx_http_scgi_params_t       *params;
  604.     ngx_http_script_code_pt       code;
  605.     ngx_http_script_engine_t      e, le;
  606.     ngx_http_scgi_loc_conf_t     *scf;
  607.     ngx_http_script_len_code_pt   lcode;
  608.     u_char                        buffer[NGX_OFF_T_LEN];

  610.     content_length_n = 0;
  611.     body = r->upstream->request_bufs;

  613.     while (body) {
  614.         content_length_n += ngx_buf_size(body->buf);
  615.         body = body->next;
  616.     }

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

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

  623.     header_params = 0;
  624.     ignored = NULL;

  626.     scf = ngx_http_get_module_loc_conf(r, ngx_http_scgi_module);

  628. #if (NGX_HTTP_CACHE)
  629.     params = r->upstream->cacheable ? &scf->params_cache : &scf->params;
  630. #else
  631.     params = &scf->params;
  632. #endif

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

  637.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  638.         le.flushed = 1;

  640.         le.ip = params->lengths->elts;
  641.         le.request = r;

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

  645.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  646.             key_len = lcode(&le);

  648.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  649.             skip_empty = lcode(&le);

  651.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  652.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  653.             }
  654.             le.ip += sizeof(uintptr_t);

  656.             if (skip_empty && val_len == 0) {
  657.                 continue;
  658.             }

  660.             len += key_len + val_len + 1;
  661.         }
  662.     }

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

  666.         allocated = 0;
  667.         lowcase_key = NULL;

  669.         if (params->number) {
  670.             n = 0;
  671.             part = &r->headers_in.headers.part;

  673.             while (part) {
  674.                 n += part->nelts;
  675.                 part = part->next;
  676.             }

  678.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  679.             if (ignored == NULL) {
  680.                 return NGX_ERROR;
  681.             }
  682.         }

  684.         part = &r->headers_in.headers.part;
  685.         header = part->elts;

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

  689.             if (i >= part->nelts) {
  690.                 if (part->next == NULL) {
  691.                     break;
  692.                 }

  694.                 part = part->next;
  695.                 header = part->elts;
  696.                 i = 0;
  697.             }

  699.             if (params->number) {
  700.                 if (allocated < header[i].key.len) {
  701.                     allocated = header[i].key.len + 16;
  702.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  703.                     if (lowcase_key == NULL) {
  704.                         return NGX_ERROR;
  705.                     }
  706.                 }

  708.                 hash = 0;

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

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

  716.                     } else if (ch == '-') {
  717.                         ch = '_';
  718.                     }

  720.                     hash = ngx_hash(hash, ch);
  721.                     lowcase_key[n] = ch;
  722.                 }

  724.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  725.                     ignored[header_params++] = &header[i];
  726.                     continue;
  727.                 }
  728.             }

  730.             len += sizeof("HTTP_") - 1 + header[i].key.len + 1
  731.                 + header[i].value.len + 1;
  732.         }
  733.     }

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

  737.     b = ngx_create_temp_buf(r->pool, NGX_SIZE_T_LEN + 1 + len + 1);
  738.     if (b == NULL) {
  739.         return NGX_ERROR;
  740.     }

  742.     cl = ngx_alloc_chain_link(r->pool);
  743.     if (cl == NULL) {
  744.         return NGX_ERROR;
  745.     }

  747.     cl->buf = b;

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

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

  755.         e.ip = params->values->elts;
  756.         e.pos = b->last;
  757.         e.request = r;
  758.         e.flushed = 1;

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

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

  764.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  765.             lcode(&le); /* key length */

  767.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  768.             skip_empty = lcode(&le);

  770.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  771.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  772.             }
  773.             le.ip += sizeof(uintptr_t);

  775.             if (skip_empty && val_len == 0) {
  776.                 e.skip = 1;

  778.                 while (*(uintptr_t *) e.ip) {
  779.                     code = *(ngx_http_script_code_pt *) e.ip;
  780.                     code((ngx_http_script_engine_t *) &e);
  781.                 }
  782.                 e.ip += sizeof(uintptr_t);

  784.                 e.skip = 0;

  786.                 continue;
  787.             }

  789. #if (NGX_DEBUG)
  790.             key = e.pos;
  791. #endif
  792.             code = *(ngx_http_script_code_pt *) e.ip;
  793.             code((ngx_http_script_engine_t *) & e);

  795. #if (NGX_DEBUG)
  796.             val = e.pos;
  797. #endif
  798.             while (*(uintptr_t *) e.ip) {
  799.                 code = *(ngx_http_script_code_pt *) e.ip;
  800.                 code((ngx_http_script_engine_t *) &e);
  801.             }
  802.             *e.pos++ = '\0';
  803.             e.ip += sizeof(uintptr_t);

  805.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  806.                            "scgi param: \"%s: %s\"", key, val);
  807.         }

  809.         b->last = e.pos;
  810.     }

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

  814.         part = &r->headers_in.headers.part;
  815.         header = part->elts;

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

  819.             if (i >= part->nelts) {
  820.                 if (part->next == NULL) {
  821.                     break;
  822.                 }

  824.                 part = part->next;
  825.                 header = part->elts;
  826.                 i = 0;
  827.             }

  829.             for (n = 0; n < header_params; n++) {
  830.                 if (&header[i] == ignored[n]) {
  831.                     goto next;
  832.                 }
  833.             }

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

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

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

  844.                 } else if (ch == '-') {
  845.                     ch = '_';
  846.                 }

  848.                 *b->last++ = ch;
  849.             }

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

  853.             val = b->last;
  854.             b->last = ngx_copy(val, header[i].value.data, header[i].value.len);
  855.             *b->last++ = (u_char) 0;

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

  860.         next:

  862.             continue;
  863.          }
  864.     }

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

  868.     if (scf->upstream.pass_request_body) {
  869.         body = r->upstream->request_bufs;
  870.         r->upstream->request_bufs = cl;

  872.         while (body) {
  873.             b = ngx_alloc_buf(r->pool);
  874.             if (b == NULL) {
  875.                 return NGX_ERROR;
  876.             }

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

  880.             cl->next = ngx_alloc_chain_link(r->pool);
  881.             if (cl->next == NULL) {
  882.                 return NGX_ERROR;
  883.             }

  885.             cl = cl->next;
  886.             cl->buf = b;

  888.             body = body->next;
  889.         }

  891.     } else {
  892.         r->upstream->request_bufs = cl;
  893.     }

  895.     cl->next = NULL;

  897.     return NGX_OK;
  898. }


  901. static ngx_int_t
  902. ‌ngx_http_scgi_reinit_request(ngx_http_request_t *r)
  903. {
  904.     ngx_http_status_t  *status;

  906.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  908.     if (status == NULL) {
  909.         return NGX_OK;
  910.     }

  912.     status->code = 0;
  913.     status->count = 0;
  914.     status->start = NULL;
  915.     status->end = NULL;

  917.     r->upstream->process_header = ngx_http_scgi_process_status_line;
  918.     r->state = 0;

  920.     return NGX_OK;
  921. }


  924. static ngx_int_t
  925. ‌ngx_http_scgi_process_status_line(ngx_http_request_t *r)
  926. {
  927.     size_t                len;
  928.     ngx_int_t             rc;
  929.     ngx_http_status_t    *status;
  930.     ngx_http_upstream_t  *u;

  932.     status = ngx_http_get_module_ctx(r, ngx_http_scgi_module);

  934.     if (status == NULL) {
  935.         return NGX_ERROR;
  936.     }

  938.     u = r->upstream;

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

  942.     if (rc == NGX_AGAIN) {
  943.         return rc;
  944.     }

  946.     if (rc == NGX_ERROR) {
  947.         u->process_header = ngx_http_scgi_process_header;
  948.         return ngx_http_scgi_process_header(r);
  949.     }

  951.     if (u->state && u->state->status == 0) {
  952.         u->state->status = status->code;
  953.     }

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

  957.     len = status->end - status->start;
  958.     u->headers_in.status_line.len = len;

  960.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  961.     if (u->headers_in.status_line.data == NULL) {
  962.         return NGX_ERROR;
  963.     }

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

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

  971.     u->process_header = ngx_http_scgi_process_header;

  973.     return ngx_http_scgi_process_header(r);
  974. }


  977. static ngx_int_t
  978. ‌ngx_http_scgi_process_header(ngx_http_request_t *r)
  979. {
  980.     ngx_str_t                      *status_line;
  981.     ngx_int_t                       rc, status;
  982.     ngx_table_elt_t                *h;
  983.     ngx_http_upstream_t            *u;
  984.     ngx_http_upstream_header_t     *hh;
  985.     ngx_http_upstream_main_conf_t  *umcf;

  987.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  989.     for ( ;; ) {

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

  993.         if (rc == NGX_OK) {

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

  997.             h = ngx_list_push(&r->upstream->headers_in.headers);
  998.             if (h == NULL) {
  999.                 return NGX_ERROR;
  1000.             }

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

  1004.             h->key.len = r->header_name_end - r->header_name_start;
  1005.             h->value.len = r->header_end - r->header_start;

  1007.             h->key.data = ngx_pnalloc(r->pool,
  1008.                                       h->key.len + 1 + h->value.len + 1
  1009.                                       + h->key.len);
  1010.             if (h->key.data == NULL) {
  1011.                 return NGX_ERROR;
  1012.             }

  1014.             h->value.data = h->key.data + h->key.len + 1;
  1015.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1017.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1018.             h->key.data[h->key.len] = '\0';
  1019.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1020.             h->value.data[h->value.len] = '\0';

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

  1025.             } else {
  1026.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1027.             }

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

  1032.             if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1033.                 return NGX_ERROR;
  1034.             }

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

  1039.             continue;
  1040.         }

  1042.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1049.             u = r->upstream;

  1051.             if (u->headers_in.status_n) {
  1052.                 goto done;
  1053.             }

  1055.             if (u->headers_in.status) {
  1056.                 status_line = &u->headers_in.status->value;

  1058.                 status = ngx_atoi(status_line->data, 3);
  1059.                 if (status == NGX_ERROR) {
  1060.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1061.                                   "upstream sent invalid status \"%V\"",
  1062.                                   status_line);
  1063.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1064.                 }

  1066.                 u->headers_in.status_n = status;
  1067.                 u->headers_in.status_line = *status_line;

  1069.             } else if (u->headers_in.location) {
  1070.                 u->headers_in.status_n = 302;
  1071.                 ngx_str_set(&u->headers_in.status_line,
  1072.                             "302 Moved Temporarily");

  1074.             } else {
  1075.                 u->headers_in.status_n = 200;
  1076.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1077.             }

  1079.             if (u->state && u->state->status == 0) {
  1080.                 u->state->status = u->headers_in.status_n;
  1081.             }

  1083.         done:

  1085.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1086.                 && r->headers_in.upgrade)
  1087.             {
  1088.                 u->upgrade = 1;
  1089.             }

  1091.             return NGX_OK;
  1092.         }

  1094.         if (rc == NGX_AGAIN) {
  1095.             return NGX_AGAIN;
  1096.         }

  1098.         /* there was error while a header line parsing */

  1100.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1101.                       "upstream sent invalid header");

  1103.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1104.     }
  1105. }


  1108. static void
  1109. ‌ngx_http_scgi_abort_request(ngx_http_request_t *r)
  1110. {
  1111.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1112.                    "abort http scgi request");

  1114.     return;
  1115. }


  1118. static void
  1119. ‌ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1120. {
  1121.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1122.                    "finalize http scgi request");

  1124.     return;
  1125. }


  1128. static void *
  1129. ‌ngx_http_scgi_create_main_conf(ngx_conf_t *cf)
  1130. {
  1131.     ngx_http_scgi_main_conf_t  *conf;

  1133.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_main_conf_t));
  1134.     if (conf == NULL) {
  1135.         return NULL;
  1136.     }

  1138. #if (NGX_HTTP_CACHE)
  1139.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1140.                        sizeof(ngx_http_file_cache_t *))
  1141.         != NGX_OK)
  1142.     {
  1143.         return NULL;
  1144.     }
  1145. #endif

  1147.     return conf;
  1148. }


  1151. static void *
  1152. ‌ngx_http_scgi_create_loc_conf(ngx_conf_t *cf)
  1153. {
  1154.     ngx_http_scgi_loc_conf_t  *conf;

  1156.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_scgi_loc_conf_t));
  1157.     if (conf == NULL) {
  1158.         return NULL;
  1159.     }

  1161.     conf->upstream.store = NGX_CONF_UNSET;
  1162.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1163.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1164.     conf->upstream.buffering = NGX_CONF_UNSET;
  1165.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1166.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1168.     conf->upstream.local = NGX_CONF_UNSET_PTR;

  1170.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1171.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1172.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1173.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1175.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1176.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1177.     conf->upstream.limit_rate = NGX_CONF_UNSET_SIZE;

  1179.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1180.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1181.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1183.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1184.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1186. #if (NGX_HTTP_CACHE)
  1187.     conf->upstream.cache = NGX_CONF_UNSET;
  1188.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1189.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1190.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1191.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1192.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1193.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1194.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1195.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1196. #endif

  1198.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1199.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1201.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1203.     /* "scgi_cyclic_temp_file" is disabled */
  1204.     conf->upstream.cyclic_temp_file = 0;

  1206.     conf->upstream.change_buffering = 1;

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

  1210.     return conf;
  1211. }


  1214. static char *
  1215. ‌ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1216. {
  1217.     ngx_http_scgi_loc_conf_t *prev = parent;
  1218.     ngx_http_scgi_loc_conf_t *conf = child;

  1220.     size_t                        size;
  1221.     ngx_int_t                     rc;
  1222.     ngx_hash_init_t               hash;
  1223.     ngx_http_core_loc_conf_t     *clcf;

  1225. #if (NGX_HTTP_CACHE)

  1227.     if (conf->upstream.store > 0) {
  1228.         conf->upstream.cache = 0;
  1229.     }

  1231.     if (conf->upstream.cache > 0) {
  1232.         conf->upstream.store = 0;
  1233.     }

  1235. #endif

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

  1240.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1241.         conf->upstream.store_values = prev->upstream.store_values;
  1242.     }

  1244.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1245.                               prev->upstream.store_access, 0600);

  1247.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1248.                               prev->upstream.next_upstream_tries, 0);

  1250.     ngx_conf_merge_value(conf->upstream.buffering,
  1251.                               prev->upstream.buffering, 1);

  1253.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1254.                               prev->upstream.ignore_client_abort, 0);

  1256.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1257.                               prev->upstream.force_ranges, 0);

  1259.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1260.                               prev->upstream.local, NULL);

  1262.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1263.                               prev->upstream.connect_timeout, 60000);

  1265.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1266.                               prev->upstream.send_timeout, 60000);

  1268.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1269.                               prev->upstream.read_timeout, 60000);

  1271.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1272.                               prev->upstream.next_upstream_timeout, 0);

  1274.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1275.                               prev->upstream.send_lowat, 0);

  1277.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1278.                               prev->upstream.buffer_size,
  1279.                               (size_t) ngx_pagesize);

  1281.     ngx_conf_merge_size_value(conf->upstream.limit_rate,
  1282.                               prev->upstream.limit_rate, 0);


  1285.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1286.                               8, ngx_pagesize);

  1288.     if (conf->upstream.bufs.num < 2) {
  1289.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1290.                            "there must be at least 2 \"scgi_buffers\"");
  1291.         return NGX_CONF_ERROR;
  1292.     }


  1295.     size = conf->upstream.buffer_size;
  1296.     if (size < conf->upstream.bufs.size) {
  1297.         size = conf->upstream.bufs.size;
  1298.     }


  1301.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1302.                               prev->upstream.busy_buffers_size_conf,
  1303.                               NGX_CONF_UNSET_SIZE);

  1305.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1306.         conf->upstream.busy_buffers_size = 2 * size;
  1307.     } else {
  1308.         conf->upstream.busy_buffers_size =
  1309.             conf->upstream.busy_buffers_size_conf;
  1310.     }

  1312.     if (conf->upstream.busy_buffers_size < size) {
  1313.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1314.             "\"scgi_busy_buffers_size\" must be equal to or greater "
  1315.             "than the maximum of the value of \"scgi_buffer_size\" and "
  1316.             "one of the \"scgi_buffers\"");

  1318.         return NGX_CONF_ERROR;
  1319.     }

  1321.     if (conf->upstream.busy_buffers_size
  1322.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1323.     {
  1324.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1325.             "\"scgi_busy_buffers_size\" must be less than "
  1326.             "the size of all \"scgi_buffers\" minus one buffer");

  1328.         return NGX_CONF_ERROR;
  1329.     }


  1332.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1333.                               prev->upstream.temp_file_write_size_conf,
  1334.                               NGX_CONF_UNSET_SIZE);

  1336.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1337.         conf->upstream.temp_file_write_size = 2 * size;
  1338.     } else {
  1339.         conf->upstream.temp_file_write_size =
  1340.             conf->upstream.temp_file_write_size_conf;
  1341.     }

  1343.     if (conf->upstream.temp_file_write_size < size) {
  1344.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1345.             "\"scgi_temp_file_write_size\" must be equal to or greater than "
  1346.             "the maximum of the value of \"scgi_buffer_size\" and "
  1347.             "one of the \"scgi_buffers\"");

  1349.         return NGX_CONF_ERROR;
  1350.     }


  1353.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1354.                               prev->upstream.max_temp_file_size_conf,
  1355.                               NGX_CONF_UNSET_SIZE);

  1357.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1358.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1359.     } else {
  1360.         conf->upstream.max_temp_file_size =
  1361.             conf->upstream.max_temp_file_size_conf;
  1362.     }

  1364.     if (conf->upstream.max_temp_file_size != 0
  1365.         && conf->upstream.max_temp_file_size < size)
  1366.     {
  1367.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1368.             "\"scgi_max_temp_file_size\" must be equal to zero to disable "
  1369.             "temporary files usage or must be equal to or greater than "
  1370.             "the maximum of the value of \"scgi_buffer_size\" and "
  1371.             "one of the \"scgi_buffers\"");

  1373.         return NGX_CONF_ERROR;
  1374.     }


  1377.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1378.                                  prev->upstream.ignore_headers,
  1379.                                  NGX_CONF_BITMASK_SET);


  1382.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1383.                                  prev->upstream.next_upstream,
  1384.                                  (NGX_CONF_BITMASK_SET
  1385.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1386.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1388.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1389.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1390.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1391.     }

  1393.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1394.                                   prev->upstream.temp_path,
  1395.                                   &ngx_http_scgi_temp_path)
  1396.         != NGX_OK)
  1397.     {
  1398.         return NGX_CONF_ERROR;
  1399.     }

  1401. #if (NGX_HTTP_CACHE)

  1403.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1404.         ngx_conf_merge_value(conf->upstream.cache,
  1405.                               prev->upstream.cache, 0);

  1407.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1408.         conf->upstream.cache_value = prev->upstream.cache_value;
  1409.     }

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

  1414.         shm_zone = conf->upstream.cache_zone;

  1416.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1417.                            "\"scgi_cache\" zone \"%V\" is unknown",
  1418.                            &shm_zone->shm.name);

  1420.         return NGX_CONF_ERROR;
  1421.     }

  1423.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1424.                               prev->upstream.cache_min_uses, 1);

  1426.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1427.                               prev->upstream.cache_use_stale,
  1428.                               (NGX_CONF_BITMASK_SET
  1429.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1431.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1432.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1433.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1434.     }

  1436.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1437.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1438.     }

  1440.     if (conf->upstream.cache_methods == 0) {
  1441.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1442.     }

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

  1446.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1447.                              prev->upstream.cache_bypass, NULL);

  1449.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1450.                              prev->upstream.no_cache, NULL);

  1452.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1453.                              prev->upstream.cache_valid, NULL);

  1455.     if (conf->cache_key.value.data == NULL) {
  1456.         conf->cache_key = prev->cache_key;
  1457.     }

  1459.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1460.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1461.                            "no \"scgi_cache_key\" for \"scgi_cache\"");
  1462.     }

  1464.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1465.                               prev->upstream.cache_lock, 0);

  1467.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1468.                               prev->upstream.cache_lock_timeout, 5000);

  1470.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1471.                               prev->upstream.cache_lock_age, 5000);

  1473.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1474.                               prev->upstream.cache_revalidate, 0);

  1476. #endif

  1478.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1479.                          prev->upstream.pass_request_headers, 1);
  1480.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1481.                          prev->upstream.pass_request_body, 1);

  1483.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1484.                          prev->upstream.intercept_errors, 0);

  1486.     hash.max_size = 512;
  1487.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1488.     hash.name = "scgi_hide_headers_hash";

  1490.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1491.             &prev->upstream, ngx_http_scgi_hide_headers, &hash)
  1492.         != NGX_OK)
  1493.     {
  1494.         return NGX_CONF_ERROR;
  1495.     }

  1497.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1499.     if (clcf->noname
  1500.         && conf->upstream.upstream == NULL && conf->scgi_lengths == NULL)
  1501.     {
  1502.         conf->upstream.upstream = prev->upstream.upstream;
  1503.         conf->scgi_lengths = prev->scgi_lengths;
  1504.         conf->scgi_values = prev->scgi_values;
  1505.     }

  1507.     if (clcf->lmt_excpt && clcf->handler == NULL
  1508.         && (conf->upstream.upstream || conf->scgi_lengths))
  1509.     {
  1510.         clcf->handler = ngx_http_scgi_handler;
  1511.     }

  1513.     if (conf->params_source == NULL) {
  1514.         conf->params = prev->params;
  1515. #if (NGX_HTTP_CACHE)
  1516.         conf->params_cache = prev->params_cache;
  1517. #endif
  1518.         conf->params_source = prev->params_source;
  1519.     }

  1521.     rc = ngx_http_scgi_init_params(cf, conf, &conf->params, NULL);
  1522.     if (rc != NGX_OK) {
  1523.         return NGX_CONF_ERROR;
  1524.     }

  1526. #if (NGX_HTTP_CACHE)

  1528.     if (conf->upstream.cache) {
  1529.         rc = ngx_http_scgi_init_params(cf, conf, &conf->params_cache,
  1530.                                        ngx_http_scgi_cache_headers);
  1531.         if (rc != NGX_OK) {
  1532.             return NGX_CONF_ERROR;
  1533.         }
  1534.     }

  1536. #endif

  1538.     return NGX_CONF_OK;
  1539. }


  1542. static ngx_int_t
  1543. ‌ngx_http_scgi_init_params(ngx_conf_t *cf, ngx_http_scgi_loc_conf_t *conf,
  1544.     ngx_http_scgi_params_t *params, ngx_keyval_t *default_params)
  1545. {
  1546.     u_char                       *p;
  1547.     size_t                        size;
  1548.     uintptr_t                    *code;
  1549.     ngx_uint_t                    i, nsrc;
  1550.     ngx_array_t                   headers_names, params_merged;
  1551.     ngx_keyval_t                 *h;
  1552.     ngx_hash_key_t               *hk;
  1553.     ngx_hash_init_t               hash;
  1554.     ngx_http_upstream_param_t    *src, *s;
  1555.     ngx_http_script_compile_t     sc;
  1556.     ngx_http_script_copy_code_t  *copy;

  1558.     if (params->hash.buckets) {
  1559.         return NGX_OK;
  1560.     }

  1562.     if (conf->params_source == NULL && default_params == NULL) {
  1563.         params->hash.buckets = (void *) 1;
  1564.         return NGX_OK;
  1565.     }

  1567.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  1568.     if (params->lengths == NULL) {
  1569.         return NGX_ERROR;
  1570.     }

  1572.     params->values = ngx_array_create(cf->pool, 512, 1);
  1573.     if (params->values == NULL) {
  1574.         return NGX_ERROR;
  1575.     }

  1577.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  1578.         != NGX_OK)
  1579.     {
  1580.         return NGX_ERROR;
  1581.     }

  1583.     if (conf->params_source) {
  1584.         src = conf->params_source->elts;
  1585.         nsrc = conf->params_source->nelts;

  1587.     } else {
  1588.         src = NULL;
  1589.         nsrc = 0;
  1590.     }

  1592.     if (default_params) {
  1593.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  1594.                            sizeof(ngx_http_upstream_param_t))
  1595.             != NGX_OK)
  1596.         {
  1597.             return NGX_ERROR;
  1598.         }

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

  1602.             s = ngx_array_push(&params_merged);
  1603.             if (s == NULL) {
  1604.                 return NGX_ERROR;
  1605.             }

  1607.             *s = src[i];
  1608.         }

  1610.         h = default_params;

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

  1614.             src = params_merged.elts;
  1615.             nsrc = params_merged.nelts;

  1617.             for (i = 0; i < nsrc; i++) {
  1618.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  1619.                     goto next;
  1620.                 }
  1621.             }

  1623.             s = ngx_array_push(&params_merged);
  1624.             if (s == NULL) {
  1625.                 return NGX_ERROR;
  1626.             }

  1628.             s->key = h->key;
  1629.             s->value = h->value;
  1630.             s->skip_empty = 1;

  1632.         next:

  1634.             h++;
  1635.         }

  1637.         src = params_merged.elts;
  1638.         nsrc = params_merged.nelts;
  1639.     }

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

  1643.         if (src[i].key.len > sizeof("HTTP_") - 1
  1644.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  1645.         {
  1646.             hk = ngx_array_push(&headers_names);
  1647.             if (hk == NULL) {
  1648.                 return NGX_ERROR;
  1649.             }

  1651.             hk->key.len = src[i].key.len - 5;
  1652.             hk->key.data = src[i].key.data + 5;
  1653.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  1654.             hk->value = (void *) 1;

  1656.             if (src[i].value.len == 0) {
  1657.                 continue;
  1658.             }
  1659.         }

  1661.         copy = ngx_array_push_n(params->lengths,
  1662.                                 sizeof(ngx_http_script_copy_code_t));
  1663.         if (copy == NULL) {
  1664.             return NGX_ERROR;
  1665.         }

  1667.         copy->code = (ngx_http_script_code_pt) ngx_http_script_copy_len_code;
  1668.         copy->len = src[i].key.len + 1;

  1670.         copy = ngx_array_push_n(params->lengths,
  1671.                                 sizeof(ngx_http_script_copy_code_t));
  1672.         if (copy == NULL) {
  1673.             return NGX_ERROR;
  1674.         }

  1676.         copy->code = (ngx_http_script_code_pt) ngx_http_script_copy_len_code;
  1677.         copy->len = src[i].skip_empty;


  1680.         size = (sizeof(ngx_http_script_copy_code_t)
  1681.                 + src[i].key.len + 1 + sizeof(uintptr_t) - 1)
  1682.                & ~(sizeof(uintptr_t) - 1);

  1684.         copy = ngx_array_push_n(params->values, size);
  1685.         if (copy == NULL) {
  1686.             return NGX_ERROR;
  1687.         }

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

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


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

  1698.         sc.cf = cf;
  1699.         sc.source = &src[i].value;
  1700.         sc.flushes = &params->flushes;
  1701.         sc.lengths = &params->lengths;
  1702.         sc.values = &params->values;

  1704.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1705.             return NGX_ERROR;
  1706.         }

  1708.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1709.         if (code == NULL) {
  1710.             return NGX_ERROR;
  1711.         }

  1713.         *code = (uintptr_t) NULL;


  1716.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  1717.         if (code == NULL) {
  1718.             return NGX_ERROR;
  1719.         }

  1721.         *code = (uintptr_t) NULL;
  1722.     }

  1724.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1725.     if (code == NULL) {
  1726.         return NGX_ERROR;
  1727.     }

  1729.     *code = (uintptr_t) NULL;

  1731.     params->number = headers_names.nelts;

  1733.     hash.hash = &params->hash;
  1734.     hash.key = ngx_hash_key_lc;
  1735.     hash.max_size = 512;
  1736.     hash.bucket_size = 64;
  1737.     hash.name = "scgi_params_hash";
  1738.     hash.pool = cf->pool;
  1739.     hash.temp_pool = NULL;

  1741.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  1742. }


  1745. static char *
  1746. ‌ngx_http_scgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1747. {
  1748.     ngx_http_scgi_loc_conf_t *scf = conf;

  1750.     ngx_url_t                   u;
  1751.     ngx_str_t                  *value, *url;
  1752.     ngx_uint_t                  n;
  1753.     ngx_http_core_loc_conf_t   *clcf;
  1754.     ngx_http_script_compile_t   sc;

  1756.     if (scf->upstream.upstream || scf->scgi_lengths) {
  1757.         return "is duplicate";
  1758.     }

  1760.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  1761.     clcf->handler = ngx_http_scgi_handler;

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

  1765.     url = &value[1];

  1767.     n = ngx_http_script_variables_count(url);

  1769.     if (n) {

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

  1773.         sc.cf = cf;
  1774.         sc.source = url;
  1775.         sc.lengths = &scf->scgi_lengths;
  1776.         sc.values = &scf->scgi_values;
  1777.         sc.variables = n;
  1778.         sc.complete_lengths = 1;
  1779.         sc.complete_values = 1;

  1781.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1782.             return NGX_CONF_ERROR;
  1783.         }

  1785.         return NGX_CONF_OK;
  1786.     }

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

  1790.     u.url = value[1];
  1791.     u.no_resolve = 1;

  1793.     scf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  1794.     if (scf->upstream.upstream == NULL) {
  1795.         return NGX_CONF_ERROR;
  1796.     }

  1798.     if (clcf->name.data[clcf->name.len - 1] == '/') {
  1799.         clcf->auto_redirect = 1;
  1800.     }

  1802.     return NGX_CONF_OK;
  1803. }


  1806. static char *
  1807. ‌ngx_http_scgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1808. {
  1809.     ngx_http_scgi_loc_conf_t *scf = conf;

  1811.     ngx_str_t                  *value;
  1812.     ngx_http_script_compile_t   sc;

  1814.     if (scf->upstream.store != NGX_CONF_UNSET) {
  1815.         return "is duplicate";
  1816.     }

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

  1820.     if (ngx_strcmp(value[1].data, "off") == 0) {
  1821.         scf->upstream.store = 0;
  1822.         return NGX_CONF_OK;
  1823.     }

  1825. #if (NGX_HTTP_CACHE)
  1826.     if (scf->upstream.cache > 0) {
  1827.         return "is incompatible with \"scgi_cache\"";
  1828.     }
  1829. #endif

  1831.     scf->upstream.store = 1;

  1833.     if (ngx_strcmp(value[1].data, "on") == 0) {
  1834.         return NGX_CONF_OK;
  1835.     }

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

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

  1842.     sc.cf = cf;
  1843.     sc.source = &value[1];
  1844.     sc.lengths = &scf->upstream.store_lengths;
  1845.     sc.values = &scf->upstream.store_values;
  1846.     sc.variables = ngx_http_script_variables_count(&value[1]);
  1847.     sc.complete_lengths = 1;
  1848.     sc.complete_values = 1;

  1850.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  1851.         return NGX_CONF_ERROR;
  1852.     }

  1854.     return NGX_CONF_OK;
  1855. }


  1858. #if (NGX_HTTP_CACHE)

  1860. static char *
  1861. ‌ngx_http_scgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1862. {
  1863.     ngx_http_scgi_loc_conf_t *scf = conf;

  1865.     ngx_str_t                         *value;
  1866.     ngx_http_complex_value_t           cv;
  1867.     ngx_http_compile_complex_value_t   ccv;

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

  1871.     if (scf->upstream.cache != NGX_CONF_UNSET) {
  1872.         return "is duplicate";
  1873.     }

  1875.     if (ngx_strcmp(value[1].data, "off") == 0) {
  1876.         scf->upstream.cache = 0;
  1877.         return NGX_CONF_OK;
  1878.     }

  1880.     if (scf->upstream.store > 0) {
  1881.         return "is incompatible with \"scgi_store\"";
  1882.     }

  1884.     scf->upstream.cache = 1;

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

  1888.     ccv.cf = cf;
  1889.     ccv.value = &value[1];
  1890.     ccv.complex_value = &cv;

  1892.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1893.         return NGX_CONF_ERROR;
  1894.     }

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

  1898.         scf->upstream.cache_value = ngx_palloc(cf->pool,
  1899.                                              sizeof(ngx_http_complex_value_t));
  1900.         if (scf->upstream.cache_value == NULL) {
  1901.             return NGX_CONF_ERROR;
  1902.         }

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

  1906.         return NGX_CONF_OK;
  1907.     }

  1909.     scf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  1910.                                                      &ngx_http_scgi_module);
  1911.     if (scf->upstream.cache_zone == NULL) {
  1912.         return NGX_CONF_ERROR;
  1913.     }

  1915.     return NGX_CONF_OK;
  1916. }


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

  1924.     ngx_str_t                         *value;
  1925.     ngx_http_compile_complex_value_t   ccv;

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

  1929.     if (scf->cache_key.value.data) {
  1930.         return "is duplicate";
  1931.     }

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

  1935.     ccv.cf = cf;
  1936.     ccv.value = &value[1];
  1937.     ccv.complex_value = &scf->cache_key;

  1939.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1940.         return NGX_CONF_ERROR;
  1941.     }

  1943.     return NGX_CONF_OK;
  1944. }

  1946. #endif

One Level Up Top Level