One Level Up Top Level

src/http/modules/ngx_http_uwsgi_module.c - nginx

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Unbit S.a.s. 2009-2010
  4. * Copyright (C) 2008 Manlio Perillo (manlio.perillo@gmail.com)
  5. * Copyright (C) Igor Sysoev
  6. * Copyright (C) Nginx, Inc.
  7. */


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


  15. ‌typedef struct {
  16.     ngx_array_t                caches;  /* ngx_http_file_cache_t * */
  17. ‌} ngx_http_uwsgi_main_conf_t;


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


  29. ‌typedef struct {
  30.     ngx_http_upstream_conf_t   upstream;

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

  38.     ngx_array_t               *uwsgi_lengths;
  39.     ngx_array_t               *uwsgi_values;

  41. #if (NGX_HTTP_CACHE)
  42.     ngx_http_complex_value_t   cache_key;
  43. #endif

  45.     ngx_str_t                  uwsgi_string;

  47.     ngx_uint_t                 modifier1;
  48.     ngx_uint_t                 modifier2;

  50. #if (NGX_HTTP_SSL)
  51.     ngx_uint_t                 ssl;
  52.     ngx_uint_t                 ssl_protocols;
  53.     ngx_str_t                  ssl_ciphers;
  54.     ngx_uint_t                 ssl_verify_depth;
  55.     ngx_str_t                  ssl_trusted_certificate;
  56.     ngx_str_t                  ssl_crl;
  57.     ngx_array_t               *ssl_conf_commands;
  58. #endif
  59. ‌} ngx_http_uwsgi_loc_conf_t;


  62. static ngx_int_t ngx_http_uwsgi_eval(ngx_http_request_t *r,
  63.     ngx_http_uwsgi_loc_conf_t *uwcf);
  64. static ngx_int_t ngx_http_uwsgi_create_request(ngx_http_request_t *r);
  65. static ngx_int_t ngx_http_uwsgi_reinit_request(ngx_http_request_t *r);
  66. static ngx_int_t ngx_http_uwsgi_process_status_line(ngx_http_request_t *r);
  67. static ngx_int_t ngx_http_uwsgi_process_header(ngx_http_request_t *r);
  68. static ngx_int_t ngx_http_uwsgi_input_filter_init(void *data);
  69. static void ngx_http_uwsgi_abort_request(ngx_http_request_t *r);
  70. static void ngx_http_uwsgi_finalize_request(ngx_http_request_t *r,
  71.     ngx_int_t rc);

  73. static void *ngx_http_uwsgi_create_main_conf(ngx_conf_t *cf);
  74. static void *ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf);
  75. static char *ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent,
  76.     void *child);
  77. static ngx_int_t ngx_http_uwsgi_init_params(ngx_conf_t *cf,
  78.     ngx_http_uwsgi_loc_conf_t *conf, ngx_http_uwsgi_params_t *params,
  79.     ngx_keyval_t *default_params);

  81. static char *ngx_http_uwsgi_pass(ngx_conf_t *cf, ngx_command_t *cmd,
  82.     void *conf);
  83. static char *ngx_http_uwsgi_store(ngx_conf_t *cf, ngx_command_t *cmd,
  84.     void *conf);

  86. #if (NGX_HTTP_CACHE)
  87. static ngx_int_t ngx_http_uwsgi_create_key(ngx_http_request_t *r);
  88. static char *ngx_http_uwsgi_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  89.     void *conf);
  90. static char *ngx_http_uwsgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd,
  91.     void *conf);
  92. #endif

  94. #if (NGX_HTTP_SSL)
  95. static char *ngx_http_uwsgi_ssl_certificate_cache(ngx_conf_t *cf,
  96.     ngx_command_t *cmd, void *conf);
  97. static char *ngx_http_uwsgi_ssl_password_file(ngx_conf_t *cf,
  98.     ngx_command_t *cmd, void *conf);
  99. static char *ngx_http_uwsgi_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  100.     void *data);
  101. static ngx_int_t ngx_http_uwsgi_merge_ssl(ngx_conf_t *cf,
  102.     ngx_http_uwsgi_loc_conf_t *conf, ngx_http_uwsgi_loc_conf_t *prev);
  103. static ngx_int_t ngx_http_uwsgi_set_ssl(ngx_conf_t *cf,
  104.     ngx_http_uwsgi_loc_conf_t *uwcf);
  105. #endif


  108. ‌static ngx_conf_num_bounds_t  ngx_http_uwsgi_modifier_bounds = {
  109.     ngx_conf_check_num_bounds, 0, 255
  110. };


  113. ‌static ngx_conf_bitmask_t ngx_http_uwsgi_next_upstream_masks[] = {
  114.     { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
  115.     { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
  116.     { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
  117.     { ngx_string("non_idempotent"), NGX_HTTP_UPSTREAM_FT_NON_IDEMPOTENT },
  118.     { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  119.     { ngx_string("http_503"), NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  120.     { ngx_string("http_403"), NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  121.     { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  122.     { ngx_string("http_429"), NGX_HTTP_UPSTREAM_FT_HTTP_429 },
  123.     { ngx_string("updating"), NGX_HTTP_UPSTREAM_FT_UPDATING },
  124.     { ngx_string("off"), NGX_HTTP_UPSTREAM_FT_OFF },
  125.     { ngx_null_string, 0 }
  126. };


  129. #if (NGX_HTTP_SSL)

  131. ‌static ngx_conf_bitmask_t  ngx_http_uwsgi_ssl_protocols[] = {
  132.     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
  133.     { ngx_string("SSLv3"), NGX_SSL_SSLv3 },
  134.     { ngx_string("TLSv1"), NGX_SSL_TLSv1 },
  135.     { ngx_string("TLSv1.1"), NGX_SSL_TLSv1_1 },
  136.     { ngx_string("TLSv1.2"), NGX_SSL_TLSv1_2 },
  137.     { ngx_string("TLSv1.3"), NGX_SSL_TLSv1_3 },
  138.     { ngx_null_string, 0 }
  139. };

  141. ‌static ngx_conf_post_t  ngx_http_uwsgi_ssl_conf_command_post =
  142.     { ngx_http_uwsgi_ssl_conf_command_check };

  144. #endif


  147. ‌ngx_module_t  ngx_http_uwsgi_module;


  150. ‌static ngx_command_t ngx_http_uwsgi_commands[] = {

  152.     { ngx_string("uwsgi_pass"),
  153.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  154.       ngx_http_uwsgi_pass,
  155.       NGX_HTTP_LOC_CONF_OFFSET,
  156.       0,
  157.       NULL },

  159.     { ngx_string("uwsgi_modifier1"),
  160.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  161.       ngx_conf_set_num_slot,
  162.       NGX_HTTP_LOC_CONF_OFFSET,
  163.       offsetof(ngx_http_uwsgi_loc_conf_t, modifier1),
  164.       &ngx_http_uwsgi_modifier_bounds },

  166.     { ngx_string("uwsgi_modifier2"),
  167.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  168.       ngx_conf_set_num_slot,
  169.       NGX_HTTP_LOC_CONF_OFFSET,
  170.       offsetof(ngx_http_uwsgi_loc_conf_t, modifier2),
  171.       &ngx_http_uwsgi_modifier_bounds },

  173.     { ngx_string("uwsgi_store"),
  174.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  175.       ngx_http_uwsgi_store,
  176.       NGX_HTTP_LOC_CONF_OFFSET,
  177.       0,
  178.       NULL },

  180.     { ngx_string("uwsgi_store_access"),
  181.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  182.       ngx_conf_set_access_slot,
  183.       NGX_HTTP_LOC_CONF_OFFSET,
  184.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.store_access),
  185.       NULL },

  187.     { ngx_string("uwsgi_buffering"),
  188.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  189.       ngx_conf_set_flag_slot,
  190.       NGX_HTTP_LOC_CONF_OFFSET,
  191.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.buffering),
  192.       NULL },

  194.     { ngx_string("uwsgi_request_buffering"),
  195.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  196.       ngx_conf_set_flag_slot,
  197.       NGX_HTTP_LOC_CONF_OFFSET,
  198.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.request_buffering),
  199.       NULL },

  201.     { ngx_string("uwsgi_ignore_client_abort"),
  202.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  203.       ngx_conf_set_flag_slot,
  204.       NGX_HTTP_LOC_CONF_OFFSET,
  205.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ignore_client_abort),
  206.       NULL },

  208.     { ngx_string("uwsgi_bind"),
  209.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE12,
  210.       ngx_http_upstream_bind_set_slot,
  211.       NGX_HTTP_LOC_CONF_OFFSET,
  212.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.local),
  213.       NULL },

  215.     { ngx_string("uwsgi_socket_keepalive"),
  216.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  217.       ngx_conf_set_flag_slot,
  218.       NGX_HTTP_LOC_CONF_OFFSET,
  219.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.socket_keepalive),
  220.       NULL },

  222.     { ngx_string("uwsgi_connect_timeout"),
  223.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  224.       ngx_conf_set_msec_slot,
  225.       NGX_HTTP_LOC_CONF_OFFSET,
  226.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.connect_timeout),
  227.       NULL },

  229.     { ngx_string("uwsgi_send_timeout"),
  230.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  231.       ngx_conf_set_msec_slot,
  232.       NGX_HTTP_LOC_CONF_OFFSET,
  233.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.send_timeout),
  234.       NULL },

  236.     { ngx_string("uwsgi_buffer_size"),
  237.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  238.       ngx_conf_set_size_slot,
  239.       NGX_HTTP_LOC_CONF_OFFSET,
  240.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.buffer_size),
  241.       NULL },

  243.     { ngx_string("uwsgi_pass_request_headers"),
  244.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  245.       ngx_conf_set_flag_slot,
  246.       NGX_HTTP_LOC_CONF_OFFSET,
  247.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_request_headers),
  248.       NULL },

  250.     { ngx_string("uwsgi_pass_request_body"),
  251.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  252.       ngx_conf_set_flag_slot,
  253.       NGX_HTTP_LOC_CONF_OFFSET,
  254.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_request_body),
  255.       NULL },

  257.     { ngx_string("uwsgi_intercept_errors"),
  258.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  259.       ngx_conf_set_flag_slot,
  260.       NGX_HTTP_LOC_CONF_OFFSET,
  261.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.intercept_errors),
  262.       NULL },

  264.     { ngx_string("uwsgi_read_timeout"),
  265.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  266.       ngx_conf_set_msec_slot,
  267.       NGX_HTTP_LOC_CONF_OFFSET,
  268.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.read_timeout),
  269.       NULL },

  271.     { ngx_string("uwsgi_buffers"),
  272.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  273.       ngx_conf_set_bufs_slot,
  274.       NGX_HTTP_LOC_CONF_OFFSET,
  275.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.bufs),
  276.       NULL },

  278.     { ngx_string("uwsgi_busy_buffers_size"),
  279.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  280.       ngx_conf_set_size_slot,
  281.       NGX_HTTP_LOC_CONF_OFFSET,
  282.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.busy_buffers_size_conf),
  283.       NULL },

  285.     { ngx_string("uwsgi_force_ranges"),
  286.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  287.       ngx_conf_set_flag_slot,
  288.       NGX_HTTP_LOC_CONF_OFFSET,
  289.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.force_ranges),
  290.       NULL },

  292.     { ngx_string("uwsgi_limit_rate"),
  293.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  294.       ngx_http_set_complex_value_size_slot,
  295.       NGX_HTTP_LOC_CONF_OFFSET,
  296.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.limit_rate),
  297.       NULL },

  299. #if (NGX_HTTP_CACHE)

  301.     { ngx_string("uwsgi_cache"),
  302.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  303.       ngx_http_uwsgi_cache,
  304.       NGX_HTTP_LOC_CONF_OFFSET,
  305.       0,
  306.       NULL },

  308.     { ngx_string("uwsgi_cache_key"),
  309.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  310.       ngx_http_uwsgi_cache_key,
  311.       NGX_HTTP_LOC_CONF_OFFSET,
  312.       0,
  313.       NULL },

  315.     { ngx_string("uwsgi_cache_path"),
  316.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  317.       ngx_http_file_cache_set_slot,
  318.       NGX_HTTP_MAIN_CONF_OFFSET,
  319.       offsetof(ngx_http_uwsgi_main_conf_t, caches),
  320.       &ngx_http_uwsgi_module },

  322.     { ngx_string("uwsgi_cache_bypass"),
  323.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  324.       ngx_http_set_predicate_slot,
  325.       NGX_HTTP_LOC_CONF_OFFSET,
  326.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_bypass),
  327.       NULL },

  329.     { ngx_string("uwsgi_no_cache"),
  330.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  331.       ngx_http_set_predicate_slot,
  332.       NGX_HTTP_LOC_CONF_OFFSET,
  333.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.no_cache),
  334.       NULL },

  336.     { ngx_string("uwsgi_cache_valid"),
  337.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  338.       ngx_http_file_cache_valid_set_slot,
  339.       NGX_HTTP_LOC_CONF_OFFSET,
  340.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_valid),
  341.       NULL },

  343.     { ngx_string("uwsgi_cache_min_uses"),
  344.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  345.       ngx_conf_set_num_slot,
  346.       NGX_HTTP_LOC_CONF_OFFSET,
  347.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_min_uses),
  348.       NULL },

  350.     { ngx_string("uwsgi_cache_max_range_offset"),
  351.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  352.       ngx_conf_set_off_slot,
  353.       NGX_HTTP_LOC_CONF_OFFSET,
  354.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_max_range_offset),
  355.       NULL },

  357.     { ngx_string("uwsgi_cache_use_stale"),
  358.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  359.       ngx_conf_set_bitmask_slot,
  360.       NGX_HTTP_LOC_CONF_OFFSET,
  361.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_use_stale),
  362.       &ngx_http_uwsgi_next_upstream_masks },

  364.     { ngx_string("uwsgi_cache_methods"),
  365.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  366.       ngx_conf_set_bitmask_slot,
  367.       NGX_HTTP_LOC_CONF_OFFSET,
  368.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_methods),
  369.       &ngx_http_upstream_cache_method_mask },

  371.     { ngx_string("uwsgi_cache_lock"),
  372.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  373.       ngx_conf_set_flag_slot,
  374.       NGX_HTTP_LOC_CONF_OFFSET,
  375.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock),
  376.       NULL },

  378.     { ngx_string("uwsgi_cache_lock_timeout"),
  379.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  380.       ngx_conf_set_msec_slot,
  381.       NGX_HTTP_LOC_CONF_OFFSET,
  382.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock_timeout),
  383.       NULL },

  385.     { ngx_string("uwsgi_cache_lock_age"),
  386.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  387.       ngx_conf_set_msec_slot,
  388.       NGX_HTTP_LOC_CONF_OFFSET,
  389.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock_age),
  390.       NULL },

  392.     { ngx_string("uwsgi_cache_revalidate"),
  393.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  394.       ngx_conf_set_flag_slot,
  395.       NGX_HTTP_LOC_CONF_OFFSET,
  396.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_revalidate),
  397.       NULL },

  399.     { ngx_string("uwsgi_cache_background_update"),
  400.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  401.       ngx_conf_set_flag_slot,
  402.       NGX_HTTP_LOC_CONF_OFFSET,
  403.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_background_update),
  404.       NULL },

  406. #endif

  408.     { ngx_string("uwsgi_temp_path"),
  409.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  410.       ngx_conf_set_path_slot,
  411.       NGX_HTTP_LOC_CONF_OFFSET,
  412.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.temp_path),
  413.       NULL },

  415.     { ngx_string("uwsgi_max_temp_file_size"),
  416.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  417.       ngx_conf_set_size_slot,
  418.       NGX_HTTP_LOC_CONF_OFFSET,
  419.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.max_temp_file_size_conf),
  420.       NULL },

  422.     { ngx_string("uwsgi_temp_file_write_size"),
  423.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  424.       ngx_conf_set_size_slot,
  425.       NGX_HTTP_LOC_CONF_OFFSET,
  426.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.temp_file_write_size_conf),
  427.       NULL },

  429.     { ngx_string("uwsgi_next_upstream"),
  430.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  431.       ngx_conf_set_bitmask_slot,
  432.       NGX_HTTP_LOC_CONF_OFFSET,
  433.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream),
  434.       &ngx_http_uwsgi_next_upstream_masks },

  436.     { ngx_string("uwsgi_next_upstream_tries"),
  437.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  438.       ngx_conf_set_num_slot,
  439.       NGX_HTTP_LOC_CONF_OFFSET,
  440.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream_tries),
  441.       NULL },

  443.     { ngx_string("uwsgi_next_upstream_timeout"),
  444.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  445.       ngx_conf_set_msec_slot,
  446.       NGX_HTTP_LOC_CONF_OFFSET,
  447.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream_timeout),
  448.       NULL },

  450.     { ngx_string("uwsgi_param"),
  451.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  452.       ngx_http_upstream_param_set_slot,
  453.       NGX_HTTP_LOC_CONF_OFFSET,
  454.       offsetof(ngx_http_uwsgi_loc_conf_t, params_source),
  455.       NULL },

  457.     { ngx_string("uwsgi_string"),
  458.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  459.       ngx_conf_set_str_slot,
  460.       NGX_HTTP_LOC_CONF_OFFSET,
  461.       offsetof(ngx_http_uwsgi_loc_conf_t, uwsgi_string),
  462.       NULL },

  464.     { ngx_string("uwsgi_pass_header"),
  465.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  466.       ngx_conf_set_str_array_slot,
  467.       NGX_HTTP_LOC_CONF_OFFSET,
  468.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_headers),
  469.       NULL },

  471.     { ngx_string("uwsgi_hide_header"),
  472.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  473.       ngx_conf_set_str_array_slot,
  474.       NGX_HTTP_LOC_CONF_OFFSET,
  475.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.hide_headers),
  476.       NULL },

  478.     { ngx_string("uwsgi_ignore_headers"),
  479.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  480.       ngx_conf_set_bitmask_slot,
  481.       NGX_HTTP_LOC_CONF_OFFSET,
  482.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ignore_headers),
  483.       &ngx_http_upstream_ignore_headers_masks },

  485. #if (NGX_HTTP_SSL)

  487.     { ngx_string("uwsgi_ssl_session_reuse"),
  488.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  489.       ngx_conf_set_flag_slot,
  490.       NGX_HTTP_LOC_CONF_OFFSET,
  491.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_session_reuse),
  492.       NULL },

  494.     { ngx_string("uwsgi_ssl_protocols"),
  495.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  496.       ngx_conf_set_bitmask_slot,
  497.       NGX_HTTP_LOC_CONF_OFFSET,
  498.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_protocols),
  499.       &ngx_http_uwsgi_ssl_protocols },

  501.     { ngx_string("uwsgi_ssl_ciphers"),
  502.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  503.       ngx_conf_set_str_slot,
  504.       NGX_HTTP_LOC_CONF_OFFSET,
  505.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_ciphers),
  506.       NULL },

  508.     { ngx_string("uwsgi_ssl_name"),
  509.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  510.       ngx_http_set_complex_value_slot,
  511.       NGX_HTTP_LOC_CONF_OFFSET,
  512.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_name),
  513.       NULL },

  515.     { ngx_string("uwsgi_ssl_server_name"),
  516.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  517.       ngx_conf_set_flag_slot,
  518.       NGX_HTTP_LOC_CONF_OFFSET,
  519.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_server_name),
  520.       NULL },

  522.     { ngx_string("uwsgi_ssl_verify"),
  523.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  524.       ngx_conf_set_flag_slot,
  525.       NGX_HTTP_LOC_CONF_OFFSET,
  526.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_verify),
  527.       NULL },

  529.     { ngx_string("uwsgi_ssl_verify_depth"),
  530.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  531.       ngx_conf_set_num_slot,
  532.       NGX_HTTP_LOC_CONF_OFFSET,
  533.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_verify_depth),
  534.       NULL },

  536.     { ngx_string("uwsgi_ssl_trusted_certificate"),
  537.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  538.       ngx_conf_set_str_slot,
  539.       NGX_HTTP_LOC_CONF_OFFSET,
  540.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_trusted_certificate),
  541.       NULL },

  543.     { ngx_string("uwsgi_ssl_crl"),
  544.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  545.       ngx_conf_set_str_slot,
  546.       NGX_HTTP_LOC_CONF_OFFSET,
  547.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_crl),
  548.       NULL },

  550.     { ngx_string("uwsgi_ssl_certificate"),
  551.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  552.       ngx_http_set_complex_value_zero_slot,
  553.       NGX_HTTP_LOC_CONF_OFFSET,
  554.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_certificate),
  555.       NULL },

  557.     { ngx_string("uwsgi_ssl_certificate_key"),
  558.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  559.       ngx_http_set_complex_value_zero_slot,
  560.       NGX_HTTP_LOC_CONF_OFFSET,
  561.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_certificate_key),
  562.       NULL },

  564.     { ngx_string("uwsgi_ssl_certificate_cache"),
  565.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  566.       ngx_http_uwsgi_ssl_certificate_cache,
  567.       NGX_HTTP_LOC_CONF_OFFSET,
  568.       0,
  569.       NULL },

  571.     { ngx_string("uwsgi_ssl_password_file"),
  572.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  573.       ngx_http_uwsgi_ssl_password_file,
  574.       NGX_HTTP_LOC_CONF_OFFSET,
  575.       0,
  576.       NULL },

  578.     { ngx_string("uwsgi_ssl_conf_command"),
  579.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  580.       ngx_conf_set_keyval_slot,
  581.       NGX_HTTP_LOC_CONF_OFFSET,
  582.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_conf_commands),
  583.       &ngx_http_uwsgi_ssl_conf_command_post },

  585. #endif

  587.       ngx_null_command
  588. };


  591. ‌static ngx_http_module_t ngx_http_uwsgi_module_ctx = {
  592.     NULL,                                  /* preconfiguration */
  593.     NULL,                                  /* postconfiguration */

  595.     ngx_http_uwsgi_create_main_conf,       /* create main configuration */
  596.     NULL,                                  /* init main configuration */

  598.     NULL,                                  /* create server configuration */
  599.     NULL,                                  /* merge server configuration */

  601.     ngx_http_uwsgi_create_loc_conf,        /* create location configuration */
  602.     ngx_http_uwsgi_merge_loc_conf          /* merge location configuration */
  603. };


  606. ‌ngx_module_t ngx_http_uwsgi_module = {
  607.     NGX_MODULE_V1,
  608.     &ngx_http_uwsgi_module_ctx,            /* module context */
  609.     ngx_http_uwsgi_commands,               /* module directives */
  610.     NGX_HTTP_MODULE,                       /* module type */
  611.     NULL,                                  /* init master */
  612.     NULL,                                  /* init module */
  613.     NULL,                                  /* init process */
  614.     NULL,                                  /* init thread */
  615.     NULL,                                  /* exit thread */
  616.     NULL,                                  /* exit process */
  617.     NULL,                                  /* exit master */
  618.     NGX_MODULE_V1_PADDING
  619. };


  622. ‌static ngx_str_t ngx_http_uwsgi_hide_headers[] = {
  623.     ngx_string("X-Accel-Expires"),
  624.     ngx_string("X-Accel-Redirect"),
  625.     ngx_string("X-Accel-Limit-Rate"),
  626.     ngx_string("X-Accel-Buffering"),
  627.     ngx_string("X-Accel-Charset"),
  628.     ngx_null_string
  629. };


  632. ‌static ngx_keyval_t  ngx_http_uwsgi_headers[] = {
  633.     { ngx_string("HTTP_HOST"),
  634.       ngx_string("$host$is_request_port$request_port") },
  635.     { ngx_null_string, ngx_null_string }
  636. };


  639. #if (NGX_HTTP_CACHE)

  641. ‌static ngx_keyval_t  ngx_http_uwsgi_cache_headers[] = {
  642.     { ngx_string("HTTP_HOST"),
  643.       ngx_string("$host$is_request_port$request_port") },
  644.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  645.       ngx_string("$upstream_cache_last_modified") },
  646.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  647.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  648.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  649.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  650.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  651.     { ngx_null_string, ngx_null_string }
  652. };

  654. #endif


  657. ‌static ngx_path_init_t ngx_http_uwsgi_temp_path = {
  658.     ngx_string(NGX_HTTP_UWSGI_TEMP_PATH), { 1, 2, 0 }
  659. };


  662. static ngx_int_t
  663. ‌ngx_http_uwsgi_handler(ngx_http_request_t *r)
  664. {
  665.     ngx_int_t                    rc;
  666.     ngx_http_status_t           *status;
  667.     ngx_http_upstream_t         *u;
  668.     ngx_http_uwsgi_loc_conf_t   *uwcf;
  669. #if (NGX_HTTP_CACHE)
  670.     ngx_http_uwsgi_main_conf_t  *uwmcf;
  671. #endif

  673.     if (ngx_http_upstream_create(r) != NGX_OK) {
  674.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  675.     }

  677.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  678.     if (status == NULL) {
  679.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  680.     }

  682.     ngx_http_set_ctx(r, status, ngx_http_uwsgi_module);

  684.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  686.     u = r->upstream;

  688.     if (uwcf->uwsgi_lengths == NULL) {

  690. #if (NGX_HTTP_SSL)
  691.         u->ssl = uwcf->ssl;

  693.         if (u->ssl) {
  694.             ngx_str_set(&u->schema, "suwsgi://");

  696.         } else {
  697.             ngx_str_set(&u->schema, "uwsgi://");
  698.         }
  699. #else
  700.         ngx_str_set(&u->schema, "uwsgi://");
  701. #endif

  703.     } else {
  704.         if (ngx_http_uwsgi_eval(r, uwcf) != NGX_OK) {
  705.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  706.         }
  707.     }

  709.     u->output.tag = (ngx_buf_tag_t) &ngx_http_uwsgi_module;

  711.     u->conf = &uwcf->upstream;

  713. #if (NGX_HTTP_CACHE)
  714.     uwmcf = ngx_http_get_module_main_conf(r, ngx_http_uwsgi_module);

  716.     u->caches = &uwmcf->caches;
  717.     u->create_key = ngx_http_uwsgi_create_key;
  718. #endif

  720.     u->create_request = ngx_http_uwsgi_create_request;
  721.     u->reinit_request = ngx_http_uwsgi_reinit_request;
  722.     u->process_header = ngx_http_uwsgi_process_status_line;
  723.     u->abort_request = ngx_http_uwsgi_abort_request;
  724.     u->finalize_request = ngx_http_uwsgi_finalize_request;
  725.     r->state = 0;

  727.     u->buffering = uwcf->upstream.buffering;

  729.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  730.     if (u->pipe == NULL) {
  731.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  732.     }

  734.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  735.     u->pipe->input_ctx = r;

  737.     u->input_filter_init = ngx_http_uwsgi_input_filter_init;
  738.     u->input_filter = ngx_http_upstream_non_buffered_filter;
  739.     u->input_filter_ctx = r;

  741.     if (!uwcf->upstream.request_buffering
  742.         && uwcf->upstream.pass_request_body
  743.         && !r->headers_in.chunked)
  744.     {
  745.         r->request_body_no_buffering = 1;
  746.     }

  748.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  750.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  751.         return rc;
  752.     }

  754.     return NGX_DONE;
  755. }


  758. static ngx_int_t
  759. ‌ngx_http_uwsgi_eval(ngx_http_request_t *r, ngx_http_uwsgi_loc_conf_t * uwcf)
  760. {
  761.     size_t                add;
  762.     ngx_url_t             url;
  763.     ngx_http_upstream_t  *u;

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

  767.     if (ngx_http_script_run(r, &url.url, uwcf->uwsgi_lengths->elts, 0,
  768.                             uwcf->uwsgi_values->elts)
  769.         == NULL)
  770.     {
  771.         return NGX_ERROR;
  772.     }

  774.     if (url.url.len > 8
  775.         && ngx_strncasecmp(url.url.data, (u_char *) "uwsgi://", 8) == 0)
  776.     {
  777.         add = 8;

  779.     } else if (url.url.len > 9
  780.                && ngx_strncasecmp(url.url.data, (u_char *) "suwsgi://", 9) == 0)
  781.     {

  783. #if (NGX_HTTP_SSL)
  784.         add = 9;
  785.         r->upstream->ssl = 1;
  786. #else
  787.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  788.                       "suwsgi protocol requires SSL support");
  789.         return NGX_ERROR;
  790. #endif

  792.     } else {
  793.         add = 0;
  794.     }

  796.     u = r->upstream;

  798.     if (add) {
  799.         u->schema.len = add;
  800.         u->schema.data = url.url.data;

  802.         url.url.data += add;
  803.         url.url.len -= add;

  805.     } else {
  806.         ngx_str_set(&u->schema, "uwsgi://");
  807.     }

  809.     url.no_resolve = 1;

  811.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  812.         if (url.err) {
  813.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  814.                           "%s in upstream \"%V\"", url.err, &url.url);
  815.         }

  817.         return NGX_ERROR;
  818.     }

  820.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  821.     if (u->resolved == NULL) {
  822.         return NGX_ERROR;
  823.     }

  825.     if (url.addrs) {
  826.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  827.         u->resolved->socklen = url.addrs[0].socklen;
  828.         u->resolved->name = url.addrs[0].name;
  829.         u->resolved->naddrs = 1;
  830.     }

  832.     u->resolved->host = url.host;
  833.     u->resolved->port = url.port;
  834.     u->resolved->no_port = url.no_port;

  836.     return NGX_OK;
  837. }


  840. #if (NGX_HTTP_CACHE)

  842. static ngx_int_t
  843. ‌ngx_http_uwsgi_create_key(ngx_http_request_t *r)
  844. {
  845.     ngx_str_t                  *key;
  846.     ngx_http_uwsgi_loc_conf_t  *uwcf;

  848.     key = ngx_array_push(&r->cache->keys);
  849.     if (key == NULL) {
  850.         return NGX_ERROR;
  851.     }

  853.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  855.     if (ngx_http_complex_value(r, &uwcf->cache_key, key) != NGX_OK) {
  856.         return NGX_ERROR;
  857.     }

  859.     return NGX_OK;
  860. }

  862. #endif


  865. static ngx_int_t
  866. ‌ngx_http_uwsgi_create_request(ngx_http_request_t *r)
  867. {
  868.     u_char                        ch, sep, *lowcase_key;
  869.     size_t                        key_len, val_len, len, allocated;
  870.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  871.     ngx_buf_t                    *b;
  872.     ngx_chain_t                  *cl, *body;
  873.     ngx_list_part_t              *part;
  874.     ngx_table_elt_t              *header, *hn, **ignored;
  875.     ngx_http_uwsgi_params_t      *params;
  876.     ngx_http_script_code_pt       code;
  877.     ngx_http_script_engine_t      e, le;
  878.     ngx_http_uwsgi_loc_conf_t    *uwcf;
  879.     ngx_http_script_len_code_pt   lcode;

  881.     len = 0;
  882.     header_params = 0;
  883.     ignored = NULL;

  885.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  887. #if (NGX_HTTP_CACHE)
  888.     params = r->upstream->cacheable ? &uwcf->params_cache : &uwcf->params;
  889. #else
  890.     params = &uwcf->params;
  891. #endif

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

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

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

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

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

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

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

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

  919.             len += 2 + key_len + 2 + val_len;
  920.         }
  921.     }

  923.     if (uwcf->upstream.pass_request_headers) {

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

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

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

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

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

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

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

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

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

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

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

  977.                 hash = 0;

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

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

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

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

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

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

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

  1007.         next_length:

  1009.             continue;
  1010.         }
  1011.     }

  1013.     len += uwcf->uwsgi_string.len;

  1015. #if 0
  1016.     /* allow custom uwsgi packet */
  1017.     if (len > 0 && len < 2) {
  1018.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1019.                       "uwsgi request is too little: %uz", len);
  1020.         return NGX_ERROR;
  1021.     }
  1022. #endif

  1024.     if (len > 65535) {
  1025.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1026.                       "uwsgi request is too big: %uz", len);
  1027.         return NGX_ERROR;
  1028.     }

  1030.     b = ngx_create_temp_buf(r->pool, len + 4);
  1031.     if (b == NULL) {
  1032.         return NGX_ERROR;
  1033.     }

  1035.     cl = ngx_alloc_chain_link(r->pool);
  1036.     if (cl == NULL) {
  1037.         return NGX_ERROR;
  1038.     }

  1040.     cl->buf = b;

  1042.     *b->last++ = (u_char) uwcf->modifier1;
  1043.     *b->last++ = (u_char) (len & 0xff);
  1044.     *b->last++ = (u_char) ((len >> 8) & 0xff);
  1045.     *b->last++ = (u_char) uwcf->modifier2;

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

  1050.         e.ip = params->values->elts;
  1051.         e.pos = b->last;
  1052.         e.request = r;
  1053.         e.flushed = 1;

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

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

  1059.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1060.             key_len = (u_char) lcode(&le);

  1062.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1063.             skip_empty = lcode(&le);

  1065.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1066.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1067.             }
  1068.             le.ip += sizeof(uintptr_t);

  1070.             if (skip_empty && val_len == 0) {
  1071.                 e.skip = 1;

  1073.                 while (*(uintptr_t *) e.ip) {
  1074.                     code = *(ngx_http_script_code_pt *) e.ip;
  1075.                     code((ngx_http_script_engine_t *) &e);
  1076.                 }
  1077.                 e.ip += sizeof(uintptr_t);

  1079.                 e.skip = 0;

  1081.                 continue;
  1082.             }

  1084.             *e.pos++ = (u_char) (key_len & 0xff);
  1085.             *e.pos++ = (u_char) ((key_len >> 8) & 0xff);

  1087.             code = *(ngx_http_script_code_pt *) e.ip;
  1088.             code((ngx_http_script_engine_t *) &e);

  1090.             *e.pos++ = (u_char) (val_len & 0xff);
  1091.             *e.pos++ = (u_char) ((val_len >> 8) & 0xff);

  1093.             while (*(uintptr_t *) e.ip) {
  1094.                 code = *(ngx_http_script_code_pt *) e.ip;
  1095.                 code((ngx_http_script_engine_t *) &e);
  1096.             }

  1098.             e.ip += sizeof(uintptr_t);

  1100.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1101.                            "uwsgi param: \"%*s: %*s\"",
  1102.                            key_len, e.pos - (key_len + 2 + val_len),
  1103.                            val_len, e.pos - val_len);
  1104.         }

  1106.         b->last = e.pos;
  1107.     }

  1109.     if (uwcf->upstream.pass_request_headers) {

  1111.         part = &r->headers_in.headers.part;
  1112.         header = part->elts;

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

  1116.             if (i >= part->nelts) {
  1117.                 if (part->next == NULL) {
  1118.                     break;
  1119.                 }

  1121.                 part = part->next;
  1122.                 header = part->elts;
  1123.                 i = 0;
  1124.             }

  1126.             for (n = 0; n < header_params; n++) {
  1127.                 if (&header[i] == ignored[n]) {
  1128.                     goto next_value;
  1129.                 }
  1130.             }

  1132.             key_len = sizeof("HTTP_") - 1 + header[i].key.len;
  1133.             *b->last++ = (u_char) (key_len & 0xff);
  1134.             *b->last++ = (u_char) ((key_len >> 8) & 0xff);

  1136.             b->last = ngx_cpymem(b->last, "HTTP_", sizeof("HTTP_") - 1);
  1137.             for (n = 0; n < header[i].key.len; n++) {
  1138.                 ch = header[i].key.data[n];

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

  1143.                 } else if (ch == '-') {
  1144.                     ch = '_';
  1145.                 }

  1147.                 *b->last++ = ch;
  1148.             }

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

  1152.             for (hn = header[i].next; hn; hn = hn->next) {
  1153.                 val_len += hn->value.len + 2;
  1154.             }

  1156.             *b->last++ = (u_char) (val_len & 0xff);
  1157.             *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1158.             b->last = ngx_copy(b->last, header[i].value.data,
  1159.                                header[i].value.len);

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

  1163.                 if (header[i].key.len == sizeof("Cookie") - 1
  1164.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1165.                                        sizeof("Cookie") - 1)
  1166.                        == 0)
  1167.                 {
  1168.                     sep = ';';

  1170.                 } else {
  1171.                     sep = ',';
  1172.                 }

  1174.                 for (hn = header[i].next; hn; hn = hn->next) {
  1175.                     *b->last++ = sep;
  1176.                     *b->last++ = ' ';
  1177.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1178.                 }
  1179.             }

  1181.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1182.                            "uwsgi param: \"%*s: %*s\"",
  1183.                            key_len, b->last - (key_len + 2 + val_len),
  1184.                            val_len, b->last - val_len);
  1185.         next_value:

  1187.             continue;
  1188.         }
  1189.     }

  1191.     b->last = ngx_copy(b->last, uwcf->uwsgi_string.data,
  1192.                        uwcf->uwsgi_string.len);

  1194.     if (r->request_body_no_buffering) {
  1195.         r->upstream->request_bufs = cl;

  1197.     } else if (uwcf->upstream.pass_request_body) {
  1198.         body = r->upstream->request_bufs;
  1199.         r->upstream->request_bufs = cl;

  1201.         while (body) {
  1202.             b = ngx_alloc_buf(r->pool);
  1203.             if (b == NULL) {
  1204.                 return NGX_ERROR;
  1205.             }

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

  1209.             cl->next = ngx_alloc_chain_link(r->pool);
  1210.             if (cl->next == NULL) {
  1211.                 return NGX_ERROR;
  1212.             }

  1214.             cl = cl->next;
  1215.             cl->buf = b;

  1217.             body = body->next;
  1218.         }

  1220.     } else {
  1221.         r->upstream->request_bufs = cl;
  1222.     }

  1224.     b->flush = 1;
  1225.     cl->next = NULL;

  1227.     return NGX_OK;
  1228. }


  1231. static ngx_int_t
  1232. ‌ngx_http_uwsgi_reinit_request(ngx_http_request_t *r)
  1233. {
  1234.     ngx_http_status_t  *status;

  1236.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1238.     if (status == NULL) {
  1239.         return NGX_OK;
  1240.     }

  1242.     status->code = 0;
  1243.     status->count = 0;
  1244.     status->start = NULL;
  1245.     status->end = NULL;

  1247.     r->upstream->process_header = ngx_http_uwsgi_process_status_line;
  1248.     r->state = 0;

  1250.     return NGX_OK;
  1251. }


  1254. static ngx_int_t
  1255. ‌ngx_http_uwsgi_process_status_line(ngx_http_request_t *r)
  1256. {
  1257.     size_t                 len;
  1258.     ngx_int_t              rc;
  1259.     ngx_http_status_t     *status;
  1260.     ngx_http_upstream_t   *u;

  1262.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1264.     if (status == NULL) {
  1265.         return NGX_ERROR;
  1266.     }

  1268.     u = r->upstream;

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

  1272.     if (rc == NGX_AGAIN) {
  1273.         return rc;
  1274.     }

  1276.     if (rc == NGX_ERROR) {
  1277.         u->process_header = ngx_http_uwsgi_process_header;
  1278.         u->buffer.pos = status->line_start;
  1279.         r->state = 0;
  1280.         return ngx_http_uwsgi_process_header(r);
  1281.     }

  1283.     if (u->state && u->state->status == 0) {
  1284.         u->state->status = status->code;
  1285.     }

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

  1289.     len = status->end - status->start;
  1290.     u->headers_in.status_line.len = len;

  1292.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1293.     if (u->headers_in.status_line.data == NULL) {
  1294.         return NGX_ERROR;
  1295.     }

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

  1299.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1300.                    "http uwsgi status %ui \"%V\"",
  1301.                    u->headers_in.status_n, &u->headers_in.status_line);

  1303.     u->process_header = ngx_http_uwsgi_process_header;

  1305.     return ngx_http_uwsgi_process_header(r);
  1306. }


  1309. static ngx_int_t
  1310. ‌ngx_http_uwsgi_process_header(ngx_http_request_t *r)
  1311. {
  1312.     ngx_str_t                      *status_line;
  1313.     ngx_int_t                       rc, status;
  1314.     ngx_table_elt_t                *h;
  1315.     ngx_http_upstream_t            *u;
  1316.     ngx_http_upstream_header_t     *hh;
  1317.     ngx_http_upstream_main_conf_t  *umcf;

  1319.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1321.     for ( ;; ) {

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

  1325.         if (rc == NGX_OK) {

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

  1329.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1330.             if (h == NULL) {
  1331.                 return NGX_ERROR;
  1332.             }

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

  1336.             h->key.len = r->header_name_end - r->header_name_start;
  1337.             h->value.len = r->header_end - r->header_start;

  1339.             h->key.data = ngx_pnalloc(r->pool,
  1340.                                       h->key.len + 1 + h->value.len + 1
  1341.                                       + h->key.len);
  1342.             if (h->key.data == NULL) {
  1343.                 h->hash = 0;
  1344.                 return NGX_ERROR;
  1345.             }

  1347.             h->value.data = h->key.data + h->key.len + 1;
  1348.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1350.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1351.             h->key.data[h->key.len] = '\0';
  1352.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1353.             h->value.data[h->value.len] = '\0';

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

  1358.             } else {
  1359.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1360.             }

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

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

  1368.                 if (rc != NGX_OK) {
  1369.                     return rc;
  1370.                 }
  1371.             }

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

  1376.             continue;
  1377.         }

  1379.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

  1383.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1384.                            "http uwsgi header done");

  1386.             u = r->upstream;

  1388.             if (u->headers_in.status_n) {
  1389.                 goto done;
  1390.             }

  1392.             if (u->headers_in.status) {
  1393.                 status_line = &u->headers_in.status->value;

  1395.                 status = ngx_atoi(status_line->data, 3);
  1396.                 if (status == NGX_ERROR) {
  1397.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1398.                                   "upstream sent invalid status \"%V\"",
  1399.                                   status_line);
  1400.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1401.                 }

  1403.                 u->headers_in.status_n = status;

  1405.                 if (status_line->len > 3) {
  1406.                     u->headers_in.status_line = *status_line;
  1407.                 }

  1409.             } else if (u->headers_in.location) {
  1410.                 u->headers_in.status_n = 302;
  1411.                 ngx_str_set(&u->headers_in.status_line,
  1412.                             "302 Moved Temporarily");

  1414.             } else {
  1415.                 u->headers_in.status_n = 200;
  1416.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1417.             }

  1419.             if (u->state && u->state->status == 0) {
  1420.                 u->state->status = u->headers_in.status_n;
  1421.             }

  1423.         done:

  1425.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1426.                 && r->headers_in.upgrade)
  1427.             {
  1428.                 u->upgrade = 1;
  1429.             }

  1431.             return NGX_OK;
  1432.         }

  1434.         if (rc == NGX_AGAIN) {
  1435.             return NGX_AGAIN;
  1436.         }

  1438.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1440.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1441.                       "upstream sent invalid header: \"%*s\\x%02xd...\"",
  1442.                       r->header_end - r->header_name_start,
  1443.                       r->header_name_start, *r->header_end);

  1445.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1446.     }
  1447. }


  1450. static ngx_int_t
  1451. ‌ngx_http_uwsgi_input_filter_init(void *data)
  1452. {
  1453.     ngx_http_request_t   *r = data;
  1454.     ngx_http_upstream_t  *u;

  1456.     u = r->upstream;

  1458.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1459.                    "http uwsgi filter init s:%ui l:%O",
  1460.                    u->headers_in.status_n, u->headers_in.content_length_n);

  1462.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1463.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  1464.     {
  1465.         u->pipe->length = 0;
  1466.         u->length = 0;

  1468.     } else if (r->method == NGX_HTTP_HEAD) {
  1469.         u->pipe->length = -1;
  1470.         u->length = -1;

  1472.     } else {
  1473.         u->pipe->length = u->headers_in.content_length_n;
  1474.         u->length = u->headers_in.content_length_n;
  1475.     }

  1477.     return NGX_OK;
  1478. }


  1481. static void
  1482. ‌ngx_http_uwsgi_abort_request(ngx_http_request_t *r)
  1483. {
  1484.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1485.                    "abort http uwsgi request");

  1487.     return;
  1488. }


  1491. static void
  1492. ‌ngx_http_uwsgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1493. {
  1494.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1495.                    "finalize http uwsgi request");

  1497.     return;
  1498. }


  1501. static void *
  1502. ‌ngx_http_uwsgi_create_main_conf(ngx_conf_t *cf)
  1503. {
  1504.     ngx_http_uwsgi_main_conf_t  *conf;

  1506.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_main_conf_t));
  1507.     if (conf == NULL) {
  1508.         return NULL;
  1509.     }

  1511. #if (NGX_HTTP_CACHE)
  1512.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1513.                        sizeof(ngx_http_file_cache_t *))
  1514.         != NGX_OK)
  1515.     {
  1516.         return NULL;
  1517.     }
  1518. #endif

  1520.     return conf;
  1521. }


  1524. static void *
  1525. ‌ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf)
  1526. {
  1527.     ngx_http_uwsgi_loc_conf_t  *conf;

  1529.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_loc_conf_t));
  1530.     if (conf == NULL) {
  1531.         return NULL;
  1532.     }

  1534.     /*
  1535.      * set by ngx_pcalloc():
  1536.      *
  1537.      *     conf->upstream.bufs.num = 0;
  1538.      *     conf->upstream.ignore_headers = 0;
  1539.      *     conf->upstream.next_upstream = 0;
  1540.      *     conf->upstream.cache_zone = NULL;
  1541.      *     conf->upstream.cache_use_stale = 0;
  1542.      *     conf->upstream.cache_methods = 0;
  1543.      *     conf->upstream.temp_path = NULL;
  1544.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  1545.      *     conf->upstream.store_lengths = NULL;
  1546.      *     conf->upstream.store_values = NULL;
  1547.      *
  1548.      *     conf->uwsgi_string = { 0, NULL };
  1549.      *     conf->ssl = 0;
  1550.      *     conf->ssl_protocols = 0;
  1551.      *     conf->ssl_ciphers = { 0, NULL };
  1552.      *     conf->ssl_trusted_certificate = { 0, NULL };
  1553.      *     conf->ssl_crl = { 0, NULL };
  1554.      */

  1556.     conf->modifier1 = NGX_CONF_UNSET_UINT;
  1557.     conf->modifier2 = NGX_CONF_UNSET_UINT;

  1559.     conf->upstream.store = NGX_CONF_UNSET;
  1560.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1561.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1562.     conf->upstream.buffering = NGX_CONF_UNSET;
  1563.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  1564.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1565.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1567.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  1568.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;

  1570.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1571.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1572.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1573.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1575.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1576.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1577.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  1579.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1580.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1581.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1583.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1584.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1586. #if (NGX_HTTP_CACHE)
  1587.     conf->upstream.cache = NGX_CONF_UNSET;
  1588.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1589.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  1590.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1591.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1592.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1593.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1594.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1595.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1596.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1597.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  1598. #endif

  1600.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1601.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1603.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1605. #if (NGX_HTTP_SSL)
  1606.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  1607.     conf->upstream.ssl_name = NGX_CONF_UNSET_PTR;
  1608.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  1609.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  1610.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  1611.     conf->upstream.ssl_certificate = NGX_CONF_UNSET_PTR;
  1612.     conf->upstream.ssl_certificate_key = NGX_CONF_UNSET_PTR;
  1613.     conf->upstream.ssl_certificate_cache = NGX_CONF_UNSET_PTR;
  1614.     conf->upstream.ssl_passwords = NGX_CONF_UNSET_PTR;
  1615.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  1616. #endif

  1618.     /* "uwsgi_cyclic_temp_file" is disabled */
  1619.     conf->upstream.cyclic_temp_file = 0;

  1621.     conf->upstream.change_buffering = 1;

  1623.     ngx_str_set(&conf->upstream.module, "uwsgi");

  1625.     return conf;
  1626. }


  1629. static char *
  1630. ‌ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1631. {
  1632.     ngx_http_uwsgi_loc_conf_t *prev = parent;
  1633.     ngx_http_uwsgi_loc_conf_t *conf = child;

  1635.     size_t                        size;
  1636.     ngx_int_t                     rc;
  1637.     ngx_hash_init_t               hash;
  1638.     ngx_http_core_loc_conf_t     *clcf;

  1640. #if (NGX_HTTP_CACHE)

  1642.     if (conf->upstream.store > 0) {
  1643.         conf->upstream.cache = 0;
  1644.     }

  1646.     if (conf->upstream.cache > 0) {
  1647.         conf->upstream.store = 0;
  1648.     }

  1650. #endif

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

  1655.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1656.         conf->upstream.store_values = prev->upstream.store_values;
  1657.     }

  1659.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1660.                               prev->upstream.store_access, 0600);

  1662.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1663.                               prev->upstream.next_upstream_tries, 0);

  1665.     ngx_conf_merge_value(conf->upstream.buffering,
  1666.                               prev->upstream.buffering, 1);

  1668.     ngx_conf_merge_value(conf->upstream.request_buffering,
  1669.                               prev->upstream.request_buffering, 1);

  1671.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1672.                               prev->upstream.ignore_client_abort, 0);

  1674.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1675.                               prev->upstream.force_ranges, 0);

  1677.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1678.                               prev->upstream.local, NULL);

  1680.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  1681.                               prev->upstream.socket_keepalive, 0);

  1683.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1684.                               prev->upstream.connect_timeout, 60000);

  1686.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1687.                               prev->upstream.send_timeout, 60000);

  1689.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1690.                               prev->upstream.read_timeout, 60000);

  1692.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1693.                               prev->upstream.next_upstream_timeout, 0);

  1695.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1696.                               prev->upstream.send_lowat, 0);

  1698.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1699.                               prev->upstream.buffer_size,
  1700.                               (size_t) ngx_pagesize);

  1702.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  1703.                               prev->upstream.limit_rate, NULL);


  1706.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1707.                               8, ngx_pagesize);

  1709.     if (conf->upstream.bufs.num < 2) {
  1710.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1711.                            "there must be at least 2 \"uwsgi_buffers\"");
  1712.         return NGX_CONF_ERROR;
  1713.     }


  1716.     size = conf->upstream.buffer_size;
  1717.     if (size < conf->upstream.bufs.size) {
  1718.         size = conf->upstream.bufs.size;
  1719.     }


  1722.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1723.                               prev->upstream.busy_buffers_size_conf,
  1724.                               NGX_CONF_UNSET_SIZE);

  1726.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1727.         conf->upstream.busy_buffers_size = 2 * size;
  1728.     } else {
  1729.         conf->upstream.busy_buffers_size =
  1730.             conf->upstream.busy_buffers_size_conf;
  1731.     }

  1733.     if (conf->upstream.busy_buffers_size < size) {
  1734.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1735.             "\"uwsgi_busy_buffers_size\" must be equal to or greater "
  1736.             "than the maximum of the value of \"uwsgi_buffer_size\" and "
  1737.             "one of the \"uwsgi_buffers\"");

  1739.         return NGX_CONF_ERROR;
  1740.     }

  1742.     if (conf->upstream.busy_buffers_size
  1743.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1744.     {
  1745.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1746.             "\"uwsgi_busy_buffers_size\" must be less than "
  1747.             "the size of all \"uwsgi_buffers\" minus one buffer");

  1749.         return NGX_CONF_ERROR;
  1750.     }


  1753.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1754.                               prev->upstream.temp_file_write_size_conf,
  1755.                               NGX_CONF_UNSET_SIZE);

  1757.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1758.         conf->upstream.temp_file_write_size = 2 * size;
  1759.     } else {
  1760.         conf->upstream.temp_file_write_size =
  1761.             conf->upstream.temp_file_write_size_conf;
  1762.     }

  1764.     if (conf->upstream.temp_file_write_size < size) {
  1765.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1766.             "\"uwsgi_temp_file_write_size\" must be equal to or greater than "
  1767.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1768.             "one of the \"uwsgi_buffers\"");

  1770.         return NGX_CONF_ERROR;
  1771.     }


  1774.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1775.                               prev->upstream.max_temp_file_size_conf,
  1776.                               NGX_CONF_UNSET_SIZE);

  1778.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1779.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1780.     } else {
  1781.         conf->upstream.max_temp_file_size =
  1782.             conf->upstream.max_temp_file_size_conf;
  1783.     }

  1785.     if (conf->upstream.max_temp_file_size != 0
  1786.         && conf->upstream.max_temp_file_size < size)
  1787.     {
  1788.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1789.             "\"uwsgi_max_temp_file_size\" must be equal to zero to disable "
  1790.             "temporary files usage or must be equal to or greater than "
  1791.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1792.             "one of the \"uwsgi_buffers\"");

  1794.         return NGX_CONF_ERROR;
  1795.     }


  1798.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1799.                                  prev->upstream.ignore_headers,
  1800.                                  NGX_CONF_BITMASK_SET);


  1803.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1804.                                  prev->upstream.next_upstream,
  1805.                                  (NGX_CONF_BITMASK_SET
  1806.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1807.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1809.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1810.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1811.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1812.     }

  1814.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1815.                                   prev->upstream.temp_path,
  1816.                                   &ngx_http_uwsgi_temp_path)
  1817.         != NGX_CONF_OK)
  1818.     {
  1819.         return NGX_CONF_ERROR;
  1820.     }

  1822. #if (NGX_HTTP_CACHE)

  1824.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1825.         ngx_conf_merge_value(conf->upstream.cache,
  1826.                               prev->upstream.cache, 0);

  1828.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1829.         conf->upstream.cache_value = prev->upstream.cache_value;
  1830.     }

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

  1835.         shm_zone = conf->upstream.cache_zone;

  1837.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1838.                            "\"uwsgi_cache\" zone \"%V\" is unknown",
  1839.                            &shm_zone->shm.name);

  1841.         return NGX_CONF_ERROR;
  1842.     }

  1844.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1845.                               prev->upstream.cache_min_uses, 1);

  1847.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  1848.                               prev->upstream.cache_max_range_offset,
  1849.                               NGX_MAX_OFF_T_VALUE);

  1851.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1852.                               prev->upstream.cache_use_stale,
  1853.                               (NGX_CONF_BITMASK_SET
  1854.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1856.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1857.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1858.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1859.     }

  1861.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1862.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1863.     }

  1865.     if (conf->upstream.cache_methods == 0) {
  1866.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1867.     }

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

  1871.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1872.                              prev->upstream.cache_bypass, NULL);

  1874.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1875.                              prev->upstream.no_cache, NULL);

  1877.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1878.                              prev->upstream.cache_valid, NULL);

  1880.     if (conf->cache_key.value.data == NULL) {
  1881.         conf->cache_key = prev->cache_key;
  1882.     }

  1884.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1885.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1886.                            "no \"uwsgi_cache_key\" for \"uwsgi_cache\"");
  1887.     }

  1889.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1890.                               prev->upstream.cache_lock, 0);

  1892.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1893.                               prev->upstream.cache_lock_timeout, 5000);

  1895.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1896.                               prev->upstream.cache_lock_age, 5000);

  1898.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1899.                               prev->upstream.cache_revalidate, 0);

  1901.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  1902.                               prev->upstream.cache_background_update, 0);

  1904. #endif

  1906.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1907.                          prev->upstream.pass_request_headers, 1);
  1908.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1909.                          prev->upstream.pass_request_body, 1);

  1911.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1912.                          prev->upstream.intercept_errors, 0);

  1914. #if (NGX_HTTP_SSL)

  1916.     if (ngx_http_uwsgi_merge_ssl(cf, conf, prev) != NGX_OK) {
  1917.         return NGX_CONF_ERROR;
  1918.     }

  1920.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  1921.                               prev->upstream.ssl_session_reuse, 1);

  1923.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  1924.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  1926.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  1927.                              "DEFAULT");

  1929.     ngx_conf_merge_ptr_value(conf->upstream.ssl_name,
  1930.                               prev->upstream.ssl_name, NULL);
  1931.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  1932.                               prev->upstream.ssl_server_name, 0);
  1933.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  1934.                               prev->upstream.ssl_verify, 0);
  1935.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  1936.                               prev->ssl_verify_depth, 1);
  1937.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  1938.                               prev->ssl_trusted_certificate, "");
  1939.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  1941.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate,
  1942.                               prev->upstream.ssl_certificate, NULL);
  1943.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_key,
  1944.                               prev->upstream.ssl_certificate_key, NULL);
  1945.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_cache,
  1946.                               prev->upstream.ssl_certificate_cache, NULL);

  1948.     if (ngx_http_upstream_merge_ssl_passwords(cf, &conf->upstream,
  1949.                                               &prev->upstream)
  1950.         != NGX_OK)
  1951.     {
  1952.         return NGX_CONF_ERROR;
  1953.     }

  1955.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  1956.                               prev->ssl_conf_commands, NULL);

  1958.     if (conf->ssl && ngx_http_uwsgi_set_ssl(cf, conf) != NGX_OK) {
  1959.         return NGX_CONF_ERROR;
  1960.     }

  1962. #endif

  1964.     ngx_conf_merge_str_value(conf->uwsgi_string, prev->uwsgi_string, "");

  1966.     hash.max_size = 512;
  1967.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1968.     hash.name = "uwsgi_hide_headers_hash";

  1970.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1971.             &prev->upstream, ngx_http_uwsgi_hide_headers, &hash)
  1972.         != NGX_OK)
  1973.     {
  1974.         return NGX_CONF_ERROR;
  1975.     }

  1977.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1979.     if (clcf->noname
  1980.         && conf->upstream.upstream == NULL && conf->uwsgi_lengths == NULL)
  1981.     {
  1982.         conf->upstream.upstream = prev->upstream.upstream;

  1984.         conf->uwsgi_lengths = prev->uwsgi_lengths;
  1985.         conf->uwsgi_values = prev->uwsgi_values;

  1987. #if (NGX_HTTP_SSL)
  1988.         conf->ssl = prev->ssl;
  1989. #endif
  1990.     }

  1992.     if (clcf->lmt_excpt && clcf->handler == NULL
  1993.         && (conf->upstream.upstream || conf->uwsgi_lengths))
  1994.     {
  1995.         clcf->handler = ngx_http_uwsgi_handler;
  1996.     }

  1998.     ngx_conf_merge_uint_value(conf->modifier1, prev->modifier1, 0);
  1999.     ngx_conf_merge_uint_value(conf->modifier2, prev->modifier2, 0);

  2001.     if (conf->params_source == NULL) {
  2002.         conf->params = prev->params;
  2003. #if (NGX_HTTP_CACHE)
  2004.         conf->params_cache = prev->params_cache;
  2005. #endif
  2006.         conf->params_source = prev->params_source;
  2007.     }

  2009.     rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params,
  2010.                                     ngx_http_uwsgi_headers);
  2011.     if (rc != NGX_OK) {
  2012.         return NGX_CONF_ERROR;
  2013.     }

  2015. #if (NGX_HTTP_CACHE)

  2017.     if (conf->upstream.cache) {
  2018.         rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params_cache,
  2019.                                         ngx_http_uwsgi_cache_headers);
  2020.         if (rc != NGX_OK) {
  2021.             return NGX_CONF_ERROR;
  2022.         }
  2023.     }

  2025. #endif

  2027.     /*
  2028.      * special handling to preserve conf->params in the "http" section
  2029.      * to inherit it to all servers
  2030.      */

  2032.     if (prev->params.hash.buckets == NULL
  2033.         && conf->params_source == prev->params_source)
  2034.     {
  2035.         prev->params = conf->params;
  2036. #if (NGX_HTTP_CACHE)
  2037.         prev->params_cache = conf->params_cache;
  2038. #endif
  2039.     }

  2041.     return NGX_CONF_OK;
  2042. }


  2045. static ngx_int_t
  2046. ‌ngx_http_uwsgi_init_params(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  2047.     ngx_http_uwsgi_params_t *params, ngx_keyval_t *default_params)
  2048. {
  2049.     u_char                       *p;
  2050.     size_t                        size;
  2051.     uintptr_t                    *code;
  2052.     ngx_uint_t                    i, nsrc;
  2053.     ngx_array_t                   headers_names, params_merged;
  2054.     ngx_keyval_t                 *h;
  2055.     ngx_hash_key_t               *hk;
  2056.     ngx_hash_init_t               hash;
  2057.     ngx_http_upstream_param_t    *src, *s;
  2058.     ngx_http_script_compile_t     sc;
  2059.     ngx_http_script_copy_code_t  *copy;

  2061.     if (params->hash.buckets) {
  2062.         return NGX_OK;
  2063.     }

  2065.     if (conf->params_source == NULL && default_params == NULL) {
  2066.         params->hash.buckets = (void *) 1;
  2067.         return NGX_OK;
  2068.     }

  2070.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  2071.     if (params->lengths == NULL) {
  2072.         return NGX_ERROR;
  2073.     }

  2075.     params->values = ngx_array_create(cf->pool, 512, 1);
  2076.     if (params->values == NULL) {
  2077.         return NGX_ERROR;
  2078.     }

  2080.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  2081.         != NGX_OK)
  2082.     {
  2083.         return NGX_ERROR;
  2084.     }

  2086.     if (conf->params_source) {
  2087.         src = conf->params_source->elts;
  2088.         nsrc = conf->params_source->nelts;

  2090.     } else {
  2091.         src = NULL;
  2092.         nsrc = 0;
  2093.     }

  2095.     if (default_params) {
  2096.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  2097.                            sizeof(ngx_http_upstream_param_t))
  2098.             != NGX_OK)
  2099.         {
  2100.             return NGX_ERROR;
  2101.         }

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

  2105.             s = ngx_array_push(&params_merged);
  2106.             if (s == NULL) {
  2107.                 return NGX_ERROR;
  2108.             }

  2110.             *s = src[i];
  2111.         }

  2113.         h = default_params;

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

  2117.             src = params_merged.elts;
  2118.             nsrc = params_merged.nelts;

  2120.             for (i = 0; i < nsrc; i++) {
  2121.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  2122.                     goto next;
  2123.                 }
  2124.             }

  2126.             s = ngx_array_push(&params_merged);
  2127.             if (s == NULL) {
  2128.                 return NGX_ERROR;
  2129.             }

  2131.             s->key = h->key;
  2132.             s->value = h->value;
  2133.             s->skip_empty = 1;

  2135.         next:

  2137.             h++;
  2138.         }

  2140.         src = params_merged.elts;
  2141.         nsrc = params_merged.nelts;
  2142.     }

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

  2146.         if (src[i].key.len > sizeof("HTTP_") - 1
  2147.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  2148.         {
  2149.             hk = ngx_array_push(&headers_names);
  2150.             if (hk == NULL) {
  2151.                 return NGX_ERROR;
  2152.             }

  2154.             hk->key.len = src[i].key.len - 5;
  2155.             hk->key.data = src[i].key.data + 5;
  2156.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  2157.             hk->value = (void *) 1;

  2159.             if (src[i].value.len == 0) {
  2160.                 continue;
  2161.             }
  2162.         }

  2164.         copy = ngx_array_push_n(params->lengths,
  2165.                                 sizeof(ngx_http_script_copy_code_t));
  2166.         if (copy == NULL) {
  2167.             return NGX_ERROR;
  2168.         }

  2170.         copy->code = (ngx_http_script_code_pt) (void *)
  2171.                                                  ngx_http_script_copy_len_code;
  2172.         copy->len = src[i].key.len;

  2174.         copy = ngx_array_push_n(params->lengths,
  2175.                                 sizeof(ngx_http_script_copy_code_t));
  2176.         if (copy == NULL) {
  2177.             return NGX_ERROR;
  2178.         }

  2180.         copy->code = (ngx_http_script_code_pt) (void *)
  2181.                                                  ngx_http_script_copy_len_code;
  2182.         copy->len = src[i].skip_empty;


  2185.         size = (sizeof(ngx_http_script_copy_code_t)
  2186.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  2187.                & ~(sizeof(uintptr_t) - 1);

  2189.         copy = ngx_array_push_n(params->values, size);
  2190.         if (copy == NULL) {
  2191.             return NGX_ERROR;
  2192.         }

  2194.         copy->code = ngx_http_script_copy_code;
  2195.         copy->len = src[i].key.len;

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


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

  2203.         sc.cf = cf;
  2204.         sc.source = &src[i].value;
  2205.         sc.flushes = &params->flushes;
  2206.         sc.lengths = &params->lengths;
  2207.         sc.values = &params->values;

  2209.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2210.             return NGX_ERROR;
  2211.         }

  2213.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  2214.         if (code == NULL) {
  2215.             return NGX_ERROR;
  2216.         }

  2218.         *code = (uintptr_t) NULL;


  2221.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  2222.         if (code == NULL) {
  2223.             return NGX_ERROR;
  2224.         }

  2226.         *code = (uintptr_t) NULL;
  2227.     }

  2229.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  2230.     if (code == NULL) {
  2231.         return NGX_ERROR;
  2232.     }

  2234.     *code = (uintptr_t) NULL;

  2236.     params->number = headers_names.nelts;

  2238.     hash.hash = &params->hash;
  2239.     hash.key = ngx_hash_key_lc;
  2240.     hash.max_size = 512;
  2241.     hash.bucket_size = 64;
  2242.     hash.name = "uwsgi_params_hash";
  2243.     hash.pool = cf->pool;
  2244.     hash.temp_pool = NULL;

  2246.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  2247. }


  2250. static char *
  2251. ‌ngx_http_uwsgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2252. {
  2253.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2255.     size_t                      add;
  2256.     ngx_url_t                   u;
  2257.     ngx_str_t                  *value, *url;
  2258.     ngx_uint_t                  n;
  2259.     ngx_http_core_loc_conf_t   *clcf;
  2260.     ngx_http_script_compile_t   sc;

  2262.     if (uwcf->upstream.upstream || uwcf->uwsgi_lengths) {
  2263.         return "is duplicate";
  2264.     }

  2266.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  2267.     clcf->handler = ngx_http_uwsgi_handler;

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

  2271.     url = &value[1];

  2273.     n = ngx_http_script_variables_count(url);

  2275.     if (n) {

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

  2279.         sc.cf = cf;
  2280.         sc.source = url;
  2281.         sc.lengths = &uwcf->uwsgi_lengths;
  2282.         sc.values = &uwcf->uwsgi_values;
  2283.         sc.variables = n;
  2284.         sc.complete_lengths = 1;
  2285.         sc.complete_values = 1;

  2287.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2288.             return NGX_CONF_ERROR;
  2289.         }

  2291. #if (NGX_HTTP_SSL)
  2292.         uwcf->ssl = 1;
  2293. #endif

  2295.         return NGX_CONF_OK;
  2296.     }

  2298.     if (ngx_strncasecmp(url->data, (u_char *) "uwsgi://", 8) == 0) {
  2299.         add = 8;

  2301.     } else if (ngx_strncasecmp(url->data, (u_char *) "suwsgi://", 9) == 0) {

  2303. #if (NGX_HTTP_SSL)
  2304.         add = 9;
  2305.         uwcf->ssl = 1;
  2306. #else
  2307.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2308.                            "suwsgi protocol requires SSL support");
  2309.         return NGX_CONF_ERROR;
  2310. #endif

  2312.     } else {
  2313.         add = 0;
  2314.     }

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

  2318.     u.url.len = url->len - add;
  2319.     u.url.data = url->data + add;
  2320.     u.no_resolve = 1;

  2322.     uwcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  2323.     if (uwcf->upstream.upstream == NULL) {
  2324.         return NGX_CONF_ERROR;
  2325.     }

  2327.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  2328.         clcf->auto_redirect = 1;
  2329.     }

  2331.     return NGX_CONF_OK;
  2332. }


  2335. static char *
  2336. ‌ngx_http_uwsgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2337. {
  2338.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2340.     ngx_str_t                  *value;
  2341.     ngx_http_script_compile_t   sc;

  2343.     if (uwcf->upstream.store != NGX_CONF_UNSET) {
  2344.         return "is duplicate";
  2345.     }

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

  2349.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2350.         uwcf->upstream.store = 0;
  2351.         return NGX_CONF_OK;
  2352.     }

  2354.     if (value[1].len == 0) {
  2355.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  2356.         return NGX_CONF_ERROR;
  2357.     }

  2359. #if (NGX_HTTP_CACHE)

  2361.     if (uwcf->upstream.cache > 0) {
  2362.         return "is incompatible with \"uwsgi_cache\"";
  2363.     }

  2365. #endif

  2367.     uwcf->upstream.store = 1;

  2369.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2370.         return NGX_CONF_OK;
  2371.     }

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

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

  2378.     sc.cf = cf;
  2379.     sc.source = &value[1];
  2380.     sc.lengths = &uwcf->upstream.store_lengths;
  2381.     sc.values = &uwcf->upstream.store_values;
  2382.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2383.     sc.complete_lengths = 1;
  2384.     sc.complete_values = 1;

  2386.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2387.         return NGX_CONF_ERROR;
  2388.     }

  2390.     return NGX_CONF_OK;
  2391. }


  2394. #if (NGX_HTTP_CACHE)

  2396. static char *
  2397. ‌ngx_http_uwsgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2398. {
  2399.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2401.     ngx_str_t                         *value;
  2402.     ngx_http_complex_value_t           cv;
  2403.     ngx_http_compile_complex_value_t   ccv;

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

  2407.     if (uwcf->upstream.cache != NGX_CONF_UNSET) {
  2408.         return "is duplicate";
  2409.     }

  2411.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2412.         uwcf->upstream.cache = 0;
  2413.         return NGX_CONF_OK;
  2414.     }

  2416.     if (uwcf->upstream.store > 0) {
  2417.         return "is incompatible with \"uwsgi_store\"";
  2418.     }

  2420.     uwcf->upstream.cache = 1;

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

  2424.     ccv.cf = cf;
  2425.     ccv.value = &value[1];
  2426.     ccv.complex_value = &cv;

  2428.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2429.         return NGX_CONF_ERROR;
  2430.     }

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

  2434.         uwcf->upstream.cache_value = ngx_palloc(cf->pool,
  2435.                                              sizeof(ngx_http_complex_value_t));
  2436.         if (uwcf->upstream.cache_value == NULL) {
  2437.             return NGX_CONF_ERROR;
  2438.         }

  2440.         *uwcf->upstream.cache_value = cv;

  2442.         return NGX_CONF_OK;
  2443.     }

  2445.     uwcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2446.                                                       &ngx_http_uwsgi_module);
  2447.     if (uwcf->upstream.cache_zone == NULL) {
  2448.         return NGX_CONF_ERROR;
  2449.     }

  2451.     return NGX_CONF_OK;
  2452. }


  2455. static char *
  2456. ‌ngx_http_uwsgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2457. {
  2458.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2460.     ngx_str_t                         *value;
  2461.     ngx_http_compile_complex_value_t   ccv;

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

  2465.     if (uwcf->cache_key.value.data) {
  2466.         return "is duplicate";
  2467.     }

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

  2471.     ccv.cf = cf;
  2472.     ccv.value = &value[1];
  2473.     ccv.complex_value = &uwcf->cache_key;

  2475.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2476.         return NGX_CONF_ERROR;
  2477.     }

  2479.     return NGX_CONF_OK;
  2480. }

  2482. #endif


  2485. #if (NGX_HTTP_SSL)

  2487. static char *
  2488. ‌ngx_http_uwsgi_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  2489.     void *conf)
  2490. {
  2491.     ngx_http_uwsgi_loc_conf_t *plcf = conf;

  2493.     time_t       inactive, valid;
  2494.     ngx_str_t   *value, s;
  2495.     ngx_int_t    max;
  2496.     ngx_uint_t   i;

  2498.     if (plcf->upstream.ssl_certificate_cache != NGX_CONF_UNSET_PTR) {
  2499.         return "is duplicate";
  2500.     }

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

  2504.     max = 0;
  2505.     inactive = 10;
  2506.     valid = 60;

  2508.     for (i = 1; i < cf->args->nelts; i++) {

  2510.         if (ngx_strncmp(value[i].data, "max=", 4) == 0) {

  2512.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  2513.             if (max <= 0) {
  2514.                 goto failed;
  2515.             }

  2517.             continue;
  2518.         }

  2520.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  2522.             s.len = value[i].len - 9;
  2523.             s.data = value[i].data + 9;

  2525.             inactive = ngx_parse_time(&s, 1);
  2526.             if (inactive == (time_t) NGX_ERROR) {
  2527.                 goto failed;
  2528.             }

  2530.             continue;
  2531.         }

  2533.         if (ngx_strncmp(value[i].data, "valid=", 6) == 0) {

  2535.             s.len = value[i].len - 6;
  2536.             s.data = value[i].data + 6;

  2538.             valid = ngx_parse_time(&s, 1);
  2539.             if (valid == (time_t) NGX_ERROR) {
  2540.                 goto failed;
  2541.             }

  2543.             continue;
  2544.         }

  2546.         if (ngx_strcmp(value[i].data, "off") == 0) {

  2548.             plcf->upstream.ssl_certificate_cache = NULL;

  2550.             continue;
  2551.         }

  2553.     failed:

  2555.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2556.                            "invalid parameter \"%V\"", &value[i]);
  2557.         return NGX_CONF_ERROR;
  2558.     }

  2560.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  2561.         return NGX_CONF_OK;
  2562.     }

  2564.     if (max == 0) {
  2565.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2566.                            "\"uwsgi_ssl_certificate_cache\" must have "
  2567.                            "the \"max\" parameter");
  2568.         return NGX_CONF_ERROR;
  2569.     }

  2571.     plcf->upstream.ssl_certificate_cache = ngx_ssl_cache_init(cf->pool, max,
  2572.                                                               valid, inactive);
  2573.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  2574.         return NGX_CONF_ERROR;
  2575.     }

  2577.     return NGX_CONF_OK;
  2578. }


  2581. static char *
  2582. ‌ngx_http_uwsgi_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2583. {
  2584.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2586.     ngx_str_t  *value;

  2588.     if (uwcf->upstream.ssl_passwords != NGX_CONF_UNSET_PTR) {
  2589.         return "is duplicate";
  2590.     }

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

  2594.     uwcf->upstream.ssl_passwords = ngx_ssl_read_password_file(cf, &value[1]);

  2596.     if (uwcf->upstream.ssl_passwords == NULL) {
  2597.         return NGX_CONF_ERROR;
  2598.     }

  2600.     return NGX_CONF_OK;
  2601. }


  2604. static char *
  2605. ‌ngx_http_uwsgi_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  2606. {
  2607. #ifndef SSL_CONF_FLAG_FILE
  2608.     return "is not supported on this platform";
  2609. #else
  2610.     return NGX_CONF_OK;
  2611. #endif
  2612. }


  2615. static ngx_int_t
  2616. ‌ngx_http_uwsgi_merge_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  2617.     ngx_http_uwsgi_loc_conf_t *prev)
  2618. {
  2619.     ngx_uint_t  preserve;

  2621.     if (conf->ssl_protocols == 0
  2622.         && conf->ssl_ciphers.data == NULL
  2623.         && conf->upstream.ssl_certificate == NGX_CONF_UNSET_PTR
  2624.         && conf->upstream.ssl_certificate_key == NGX_CONF_UNSET_PTR
  2625.         && conf->upstream.ssl_passwords == NGX_CONF_UNSET_PTR
  2626.         && conf->upstream.ssl_verify == NGX_CONF_UNSET
  2627.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  2628.         && conf->ssl_trusted_certificate.data == NULL
  2629.         && conf->ssl_crl.data == NULL
  2630.         && conf->upstream.ssl_session_reuse == NGX_CONF_UNSET
  2631.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  2632.     {
  2633.         if (prev->upstream.ssl) {
  2634.             conf->upstream.ssl = prev->upstream.ssl;
  2635.             return NGX_OK;
  2636.         }

  2638.         preserve = 1;

  2640.     } else {
  2641.         preserve = 0;
  2642.     }

  2644.     conf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2645.     if (conf->upstream.ssl == NULL) {
  2646.         return NGX_ERROR;
  2647.     }

  2649.     conf->upstream.ssl->log = cf->log;

  2651.     /*
  2652.      * special handling to preserve conf->upstream.ssl
  2653.      * in the "http" section to inherit it to all servers
  2654.      */

  2656.     if (preserve) {
  2657.         prev->upstream.ssl = conf->upstream.ssl;
  2658.     }

  2660.     return NGX_OK;
  2661. }


  2664. static ngx_int_t
  2665. ‌ngx_http_uwsgi_set_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *uwcf)
  2666. {
  2667.     ngx_pool_cleanup_t  *cln;

  2669.     if (uwcf->upstream.ssl->ctx) {
  2670.         return NGX_OK;
  2671.     }

  2673.     if (ngx_ssl_create(uwcf->upstream.ssl, uwcf->ssl_protocols, NULL)
  2674.         != NGX_OK)
  2675.     {
  2676.         return NGX_ERROR;
  2677.     }

  2679.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2680.     if (cln == NULL) {
  2681.         ngx_ssl_cleanup_ctx(uwcf->upstream.ssl);
  2682.         return NGX_ERROR;
  2683.     }

  2685.     cln->handler = ngx_ssl_cleanup_ctx;
  2686.     cln->data = uwcf->upstream.ssl;

  2688.     if (ngx_ssl_ciphers(cf, uwcf->upstream.ssl, &uwcf->ssl_ciphers, 0)
  2689.         != NGX_OK)
  2690.     {
  2691.         return NGX_ERROR;
  2692.     }

  2694.     if (uwcf->upstream.ssl_certificate
  2695.         && uwcf->upstream.ssl_certificate->value.len)
  2696.     {
  2697.         if (uwcf->upstream.ssl_certificate_key == NULL) {
  2698.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2699.                           "no \"uwsgi_ssl_certificate_key\" is defined "
  2700.                           "for certificate \"%V\"",
  2701.                           &uwcf->upstream.ssl_certificate->value);
  2702.             return NGX_ERROR;
  2703.         }

  2705.         if (uwcf->upstream.ssl_certificate->lengths == NULL
  2706.             && uwcf->upstream.ssl_certificate_key->lengths == NULL)
  2707.         {
  2708.             if (ngx_ssl_certificate(cf, uwcf->upstream.ssl,
  2709.                                     &uwcf->upstream.ssl_certificate->value,
  2710.                                     &uwcf->upstream.ssl_certificate_key->value,
  2711.                                     uwcf->upstream.ssl_passwords)
  2712.                 != NGX_OK)
  2713.             {
  2714.                 return NGX_ERROR;
  2715.             }
  2716.         }
  2717.     }

  2719.     if (uwcf->upstream.ssl_verify) {
  2720.         if (uwcf->ssl_trusted_certificate.len == 0) {
  2721.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2722.                       "no uwsgi_ssl_trusted_certificate for uwsgi_ssl_verify");
  2723.             return NGX_ERROR;
  2724.         }

  2726.         if (ngx_ssl_trusted_certificate(cf, uwcf->upstream.ssl,
  2727.                                         &uwcf->ssl_trusted_certificate,
  2728.                                         uwcf->ssl_verify_depth)
  2729.             != NGX_OK)
  2730.         {
  2731.             return NGX_ERROR;
  2732.         }

  2734.         if (ngx_ssl_crl(cf, uwcf->upstream.ssl, &uwcf->ssl_crl) != NGX_OK) {
  2735.             return NGX_ERROR;
  2736.         }
  2737.     }

  2739.     if (ngx_ssl_client_session_cache(cf, uwcf->upstream.ssl,
  2740.                                      uwcf->upstream.ssl_session_reuse)
  2741.         != NGX_OK)
  2742.     {
  2743.         return NGX_ERROR;
  2744.     }

  2746.     if (ngx_ssl_conf_commands(cf, uwcf->upstream.ssl, uwcf->ssl_conf_commands)
  2747.         != NGX_OK)
  2748.     {
  2749.         return NGX_ERROR;
  2750.     }

  2752.     return NGX_OK;
  2753. }

  2755. #endif

One Level Up Top Level