One Level Up Top Level

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

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_socket_rcvbuf"),
  223.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  224.       ngx_conf_set_size_slot,
  225.       NGX_HTTP_LOC_CONF_OFFSET,
  226.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.socket_rcvbuf),
  227.       NULL },

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

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

  243.     { ngx_string("uwsgi_send_timeout"),
  244.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  245.       ngx_conf_set_msec_slot,
  246.       NGX_HTTP_LOC_CONF_OFFSET,
  247.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.send_timeout),
  248.       NULL },

  250.     { ngx_string("uwsgi_buffer_size"),
  251.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  252.       ngx_conf_set_size_slot,
  253.       NGX_HTTP_LOC_CONF_OFFSET,
  254.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.buffer_size),
  255.       NULL },

  257.     { ngx_string("uwsgi_pass_request_headers"),
  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.pass_request_headers),
  262.       NULL },

  264.     { ngx_string("uwsgi_pass_request_body"),
  265.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  266.       ngx_conf_set_flag_slot,
  267.       NGX_HTTP_LOC_CONF_OFFSET,
  268.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_request_body),
  269.       NULL },

  271.     { ngx_string("uwsgi_intercept_errors"),
  272.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  273.       ngx_conf_set_flag_slot,
  274.       NGX_HTTP_LOC_CONF_OFFSET,
  275.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.intercept_errors),
  276.       NULL },

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

  285.     { ngx_string("uwsgi_buffers"),
  286.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  287.       ngx_conf_set_bufs_slot,
  288.       NGX_HTTP_LOC_CONF_OFFSET,
  289.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.bufs),
  290.       NULL },

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

  299.     { ngx_string("uwsgi_force_ranges"),
  300.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  301.       ngx_conf_set_flag_slot,
  302.       NGX_HTTP_LOC_CONF_OFFSET,
  303.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.force_ranges),
  304.       NULL },

  306.     { ngx_string("uwsgi_limit_rate"),
  307.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  308.       ngx_http_set_complex_value_size_slot,
  309.       NGX_HTTP_LOC_CONF_OFFSET,
  310.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.limit_rate),
  311.       NULL },

  313. #if (NGX_HTTP_CACHE)

  315.     { ngx_string("uwsgi_cache"),
  316.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  317.       ngx_http_uwsgi_cache,
  318.       NGX_HTTP_LOC_CONF_OFFSET,
  319.       0,
  320.       NULL },

  322.     { ngx_string("uwsgi_cache_key"),
  323.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  324.       ngx_http_uwsgi_cache_key,
  325.       NGX_HTTP_LOC_CONF_OFFSET,
  326.       0,
  327.       NULL },

  329.     { ngx_string("uwsgi_cache_path"),
  330.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  331.       ngx_http_file_cache_set_slot,
  332.       NGX_HTTP_MAIN_CONF_OFFSET,
  333.       offsetof(ngx_http_uwsgi_main_conf_t, caches),
  334.       &ngx_http_uwsgi_module },

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

  343.     { ngx_string("uwsgi_no_cache"),
  344.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  345.       ngx_http_set_predicate_slot,
  346.       NGX_HTTP_LOC_CONF_OFFSET,
  347.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.no_cache),
  348.       NULL },

  350.     { ngx_string("uwsgi_cache_valid"),
  351.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  352.       ngx_http_file_cache_valid_set_slot,
  353.       NGX_HTTP_LOC_CONF_OFFSET,
  354.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_valid),
  355.       NULL },

  357.     { ngx_string("uwsgi_cache_min_uses"),
  358.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  359.       ngx_conf_set_num_slot,
  360.       NGX_HTTP_LOC_CONF_OFFSET,
  361.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_min_uses),
  362.       NULL },

  364.     { ngx_string("uwsgi_cache_max_range_offset"),
  365.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  366.       ngx_conf_set_off_slot,
  367.       NGX_HTTP_LOC_CONF_OFFSET,
  368.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_max_range_offset),
  369.       NULL },

  371.     { ngx_string("uwsgi_cache_use_stale"),
  372.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  373.       ngx_conf_set_bitmask_slot,
  374.       NGX_HTTP_LOC_CONF_OFFSET,
  375.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_use_stale),
  376.       &ngx_http_uwsgi_next_upstream_masks },

  378.     { ngx_string("uwsgi_cache_methods"),
  379.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  380.       ngx_conf_set_bitmask_slot,
  381.       NGX_HTTP_LOC_CONF_OFFSET,
  382.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_methods),
  383.       &ngx_http_upstream_cache_method_mask },

  385.     { ngx_string("uwsgi_cache_lock"),
  386.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  387.       ngx_conf_set_flag_slot,
  388.       NGX_HTTP_LOC_CONF_OFFSET,
  389.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock),
  390.       NULL },

  392.     { ngx_string("uwsgi_cache_lock_timeout"),
  393.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  394.       ngx_conf_set_msec_slot,
  395.       NGX_HTTP_LOC_CONF_OFFSET,
  396.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock_timeout),
  397.       NULL },

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

  406.     { ngx_string("uwsgi_cache_revalidate"),
  407.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  408.       ngx_conf_set_flag_slot,
  409.       NGX_HTTP_LOC_CONF_OFFSET,
  410.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_revalidate),
  411.       NULL },

  413.     { ngx_string("uwsgi_cache_background_update"),
  414.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  415.       ngx_conf_set_flag_slot,
  416.       NGX_HTTP_LOC_CONF_OFFSET,
  417.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_background_update),
  418.       NULL },

  420. #endif

  422.     { ngx_string("uwsgi_temp_path"),
  423.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  424.       ngx_conf_set_path_slot,
  425.       NGX_HTTP_LOC_CONF_OFFSET,
  426.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.temp_path),
  427.       NULL },

  429.     { ngx_string("uwsgi_max_temp_file_size"),
  430.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  431.       ngx_conf_set_size_slot,
  432.       NGX_HTTP_LOC_CONF_OFFSET,
  433.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.max_temp_file_size_conf),
  434.       NULL },

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

  443.     { ngx_string("uwsgi_next_upstream"),
  444.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  445.       ngx_conf_set_bitmask_slot,
  446.       NGX_HTTP_LOC_CONF_OFFSET,
  447.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream),
  448.       &ngx_http_uwsgi_next_upstream_masks },

  450.     { ngx_string("uwsgi_next_upstream_tries"),
  451.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  452.       ngx_conf_set_num_slot,
  453.       NGX_HTTP_LOC_CONF_OFFSET,
  454.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream_tries),
  455.       NULL },

  457.     { ngx_string("uwsgi_next_upstream_timeout"),
  458.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  459.       ngx_conf_set_msec_slot,
  460.       NGX_HTTP_LOC_CONF_OFFSET,
  461.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream_timeout),
  462.       NULL },

  464.     { ngx_string("uwsgi_param"),
  465.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  466.       ngx_http_upstream_param_set_slot,
  467.       NGX_HTTP_LOC_CONF_OFFSET,
  468.       offsetof(ngx_http_uwsgi_loc_conf_t, params_source),
  469.       NULL },

  471.     { ngx_string("uwsgi_string"),
  472.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  473.       ngx_conf_set_str_slot,
  474.       NGX_HTTP_LOC_CONF_OFFSET,
  475.       offsetof(ngx_http_uwsgi_loc_conf_t, uwsgi_string),
  476.       NULL },

  478.     { ngx_string("uwsgi_pass_header"),
  479.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  480.       ngx_conf_set_str_array_slot,
  481.       NGX_HTTP_LOC_CONF_OFFSET,
  482.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_headers),
  483.       NULL },

  485.     { ngx_string("uwsgi_hide_header"),
  486.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  487.       ngx_conf_set_str_array_slot,
  488.       NGX_HTTP_LOC_CONF_OFFSET,
  489.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.hide_headers),
  490.       NULL },

  492.     { ngx_string("uwsgi_ignore_headers"),
  493.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  494.       ngx_conf_set_bitmask_slot,
  495.       NGX_HTTP_LOC_CONF_OFFSET,
  496.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ignore_headers),
  497.       &ngx_http_upstream_ignore_headers_masks },

  499. #if (NGX_HTTP_SSL)

  501.     { ngx_string("uwsgi_ssl_session_reuse"),
  502.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  503.       ngx_conf_set_flag_slot,
  504.       NGX_HTTP_LOC_CONF_OFFSET,
  505.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_session_reuse),
  506.       NULL },

  508.     { ngx_string("uwsgi_ssl_protocols"),
  509.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  510.       ngx_conf_set_bitmask_slot,
  511.       NGX_HTTP_LOC_CONF_OFFSET,
  512.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_protocols),
  513.       &ngx_http_uwsgi_ssl_protocols },

  515.     { ngx_string("uwsgi_ssl_ciphers"),
  516.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  517.       ngx_conf_set_str_slot,
  518.       NGX_HTTP_LOC_CONF_OFFSET,
  519.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_ciphers),
  520.       NULL },

  522.     { ngx_string("uwsgi_ssl_name"),
  523.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  524.       ngx_http_set_complex_value_slot,
  525.       NGX_HTTP_LOC_CONF_OFFSET,
  526.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_name),
  527.       NULL },

  529.     { ngx_string("uwsgi_ssl_server_name"),
  530.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  531.       ngx_conf_set_flag_slot,
  532.       NGX_HTTP_LOC_CONF_OFFSET,
  533.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_server_name),
  534.       NULL },

  536.     { ngx_string("uwsgi_ssl_verify"),
  537.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  538.       ngx_conf_set_flag_slot,
  539.       NGX_HTTP_LOC_CONF_OFFSET,
  540.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_verify),
  541.       NULL },

  543.     { ngx_string("uwsgi_ssl_verify_depth"),
  544.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  545.       ngx_conf_set_num_slot,
  546.       NGX_HTTP_LOC_CONF_OFFSET,
  547.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_verify_depth),
  548.       NULL },

  550.     { ngx_string("uwsgi_ssl_trusted_certificate"),
  551.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  552.       ngx_conf_set_str_slot,
  553.       NGX_HTTP_LOC_CONF_OFFSET,
  554.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_trusted_certificate),
  555.       NULL },

  557.     { ngx_string("uwsgi_ssl_crl"),
  558.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  559.       ngx_conf_set_str_slot,
  560.       NGX_HTTP_LOC_CONF_OFFSET,
  561.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_crl),
  562.       NULL },

  564.     { ngx_string("uwsgi_ssl_certificate"),
  565.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  566.       ngx_http_set_complex_value_zero_slot,
  567.       NGX_HTTP_LOC_CONF_OFFSET,
  568.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_certificate),
  569.       NULL },

  571.     { ngx_string("uwsgi_ssl_certificate_key"),
  572.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  573.       ngx_http_set_complex_value_zero_slot,
  574.       NGX_HTTP_LOC_CONF_OFFSET,
  575.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_certificate_key),
  576.       NULL },

  578.     { ngx_string("uwsgi_ssl_certificate_cache"),
  579.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  580.       ngx_http_uwsgi_ssl_certificate_cache,
  581.       NGX_HTTP_LOC_CONF_OFFSET,
  582.       0,
  583.       NULL },

  585.     { ngx_string("uwsgi_ssl_password_file"),
  586.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  587.       ngx_http_uwsgi_ssl_password_file,
  588.       NGX_HTTP_LOC_CONF_OFFSET,
  589.       0,
  590.       NULL },

  592.     { ngx_string("uwsgi_ssl_conf_command"),
  593.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  594.       ngx_conf_set_keyval_slot,
  595.       NGX_HTTP_LOC_CONF_OFFSET,
  596.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_conf_commands),
  597.       &ngx_http_uwsgi_ssl_conf_command_post },

  599. #endif

  601.       ngx_null_command
  602. };


  605. ‌static ngx_http_module_t ngx_http_uwsgi_module_ctx = {
  606.     NULL,                                  /* preconfiguration */
  607.     NULL,                                  /* postconfiguration */

  609.     ngx_http_uwsgi_create_main_conf,       /* create main configuration */
  610.     NULL,                                  /* init main configuration */

  612.     NULL,                                  /* create server configuration */
  613.     NULL,                                  /* merge server configuration */

  615.     ngx_http_uwsgi_create_loc_conf,        /* create location configuration */
  616.     ngx_http_uwsgi_merge_loc_conf          /* merge location configuration */
  617. };


  620. ‌ngx_module_t ngx_http_uwsgi_module = {
  621.     NGX_MODULE_V1,
  622.     &ngx_http_uwsgi_module_ctx,            /* module context */
  623.     ngx_http_uwsgi_commands,               /* module directives */
  624.     NGX_HTTP_MODULE,                       /* module type */
  625.     NULL,                                  /* init master */
  626.     NULL,                                  /* init module */
  627.     NULL,                                  /* init process */
  628.     NULL,                                  /* init thread */
  629.     NULL,                                  /* exit thread */
  630.     NULL,                                  /* exit process */
  631.     NULL,                                  /* exit master */
  632.     NGX_MODULE_V1_PADDING
  633. };


  636. ‌static ngx_str_t ngx_http_uwsgi_hide_headers[] = {
  637.     ngx_string("X-Accel-Expires"),
  638.     ngx_string("X-Accel-Redirect"),
  639.     ngx_string("X-Accel-Limit-Rate"),
  640.     ngx_string("X-Accel-Buffering"),
  641.     ngx_string("X-Accel-Charset"),
  642.     ngx_null_string
  643. };


  646. ‌static ngx_keyval_t  ngx_http_uwsgi_headers[] = {
  647.     { ngx_string("HTTP_HOST"),
  648.       ngx_string("$host$is_request_port$request_port") },
  649.     { ngx_null_string, ngx_null_string }
  650. };


  653. #if (NGX_HTTP_CACHE)

  655. ‌static ngx_keyval_t  ngx_http_uwsgi_cache_headers[] = {
  656.     { ngx_string("HTTP_HOST"),
  657.       ngx_string("$host$is_request_port$request_port") },
  658.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  659.       ngx_string("$upstream_cache_last_modified") },
  660.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  661.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  662.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  663.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  664.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  665.     { ngx_null_string, ngx_null_string }
  666. };

  668. #endif


  671. ‌static ngx_path_init_t ngx_http_uwsgi_temp_path = {
  672.     ngx_string(NGX_HTTP_UWSGI_TEMP_PATH), { 1, 2, 0 }
  673. };


  676. static ngx_int_t
  677. ‌ngx_http_uwsgi_handler(ngx_http_request_t *r)
  678. {
  679.     ngx_int_t                    rc;
  680.     ngx_http_status_t           *status;
  681.     ngx_http_upstream_t         *u;
  682.     ngx_http_uwsgi_loc_conf_t   *uwcf;
  683. #if (NGX_HTTP_CACHE)
  684.     ngx_http_uwsgi_main_conf_t  *uwmcf;
  685. #endif

  687.     if (ngx_http_upstream_create(r) != NGX_OK) {
  688.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  689.     }

  691.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  692.     if (status == NULL) {
  693.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  694.     }

  696.     ngx_http_set_ctx(r, status, ngx_http_uwsgi_module);

  698.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  700.     u = r->upstream;

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

  704. #if (NGX_HTTP_SSL)
  705.         u->ssl = uwcf->ssl;

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

  710.         } else {
  711.             ngx_str_set(&u->schema, "uwsgi://");
  712.         }
  713. #else
  714.         ngx_str_set(&u->schema, "uwsgi://");
  715. #endif

  717.     } else {
  718.         if (ngx_http_uwsgi_eval(r, uwcf) != NGX_OK) {
  719.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  720.         }
  721.     }

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

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

  727. #if (NGX_HTTP_CACHE)
  728.     uwmcf = ngx_http_get_module_main_conf(r, ngx_http_uwsgi_module);

  730.     u->caches = &uwmcf->caches;
  731.     u->create_key = ngx_http_uwsgi_create_key;
  732. #endif

  734.     u->create_request = ngx_http_uwsgi_create_request;
  735.     u->reinit_request = ngx_http_uwsgi_reinit_request;
  736.     u->process_header = ngx_http_uwsgi_process_status_line;
  737.     u->abort_request = ngx_http_uwsgi_abort_request;
  738.     u->finalize_request = ngx_http_uwsgi_finalize_request;
  739.     r->state = 0;

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

  743.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  744.     if (u->pipe == NULL) {
  745.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  746.     }

  748.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  749.     u->pipe->input_ctx = r;

  751.     u->input_filter_init = ngx_http_uwsgi_input_filter_init;
  752.     u->input_filter = ngx_http_upstream_non_buffered_filter;
  753.     u->input_filter_ctx = r;

  755.     if (!uwcf->upstream.request_buffering
  756.         && uwcf->upstream.pass_request_body
  757.         && !r->headers_in.chunked)
  758.     {
  759.         r->request_body_no_buffering = 1;
  760.     }

  762.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  764.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  765.         return rc;
  766.     }

  768.     return NGX_DONE;
  769. }


  772. static ngx_int_t
  773. ‌ngx_http_uwsgi_eval(ngx_http_request_t *r, ngx_http_uwsgi_loc_conf_t * uwcf)
  774. {
  775.     size_t                add;
  776.     ngx_url_t             url;
  777.     ngx_http_upstream_t  *u;

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

  781.     if (ngx_http_script_run(r, &url.url, uwcf->uwsgi_lengths->elts, 0,
  782.                             uwcf->uwsgi_values->elts)
  783.         == NULL)
  784.     {
  785.         return NGX_ERROR;
  786.     }

  788.     if (url.url.len > 8
  789.         && ngx_strncasecmp(url.url.data, (u_char *) "uwsgi://", 8) == 0)
  790.     {
  791.         add = 8;

  793.     } else if (url.url.len > 9
  794.                && ngx_strncasecmp(url.url.data, (u_char *) "suwsgi://", 9) == 0)
  795.     {

  797. #if (NGX_HTTP_SSL)
  798.         add = 9;
  799.         r->upstream->ssl = 1;
  800. #else
  801.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  802.                       "suwsgi protocol requires SSL support");
  803.         return NGX_ERROR;
  804. #endif

  806.     } else {
  807.         add = 0;
  808.     }

  810.     u = r->upstream;

  812.     if (add) {
  813.         u->schema.len = add;
  814.         u->schema.data = url.url.data;

  816.         url.url.data += add;
  817.         url.url.len -= add;

  819.     } else {
  820.         ngx_str_set(&u->schema, "uwsgi://");
  821.     }

  823.     url.no_resolve = 1;

  825.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  826.         if (url.err) {
  827.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  828.                           "%s in upstream \"%V\"", url.err, &url.url);
  829.         }

  831.         return NGX_ERROR;
  832.     }

  834.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  835.     if (u->resolved == NULL) {
  836.         return NGX_ERROR;
  837.     }

  839.     if (url.addrs) {
  840.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  841.         u->resolved->socklen = url.addrs[0].socklen;
  842.         u->resolved->name = url.addrs[0].name;
  843.         u->resolved->naddrs = 1;
  844.     }

  846.     u->resolved->host = url.host;
  847.     u->resolved->port = url.port;
  848.     u->resolved->no_port = url.no_port;

  850.     return NGX_OK;
  851. }


  854. #if (NGX_HTTP_CACHE)

  856. static ngx_int_t
  857. ‌ngx_http_uwsgi_create_key(ngx_http_request_t *r)
  858. {
  859.     ngx_str_t                  *key;
  860.     ngx_http_uwsgi_loc_conf_t  *uwcf;

  862.     key = ngx_array_push(&r->cache->keys);
  863.     if (key == NULL) {
  864.         return NGX_ERROR;
  865.     }

  867.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  869.     if (ngx_http_complex_value(r, &uwcf->cache_key, key) != NGX_OK) {
  870.         return NGX_ERROR;
  871.     }

  873.     return NGX_OK;
  874. }

  876. #endif


  879. static ngx_int_t
  880. ‌ngx_http_uwsgi_create_request(ngx_http_request_t *r)
  881. {
  882.     u_char                        ch, sep, *lowcase_key;
  883.     size_t                        key_len, val_len, len, params_len, allocated;
  884.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  885.     ngx_buf_t                    *b;
  886.     ngx_chain_t                  *cl, *body;
  887.     ngx_list_part_t              *part;
  888.     ngx_table_elt_t              *header, *hn, **ignored;
  889.     ngx_http_uwsgi_params_t      *params;
  890.     ngx_http_script_code_pt       code;
  891.     ngx_http_script_engine_t      e, le;
  892.     ngx_http_uwsgi_loc_conf_t    *uwcf;
  893.     ngx_http_script_len_code_pt   lcode;

  895.     len = 0;
  896.     params_len = 0;
  897.     header_params = 0;
  898.     ignored = NULL;

  900.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  902. #if (NGX_HTTP_CACHE)
  903.     params = r->upstream->cacheable ? &uwcf->params_cache : &uwcf->params;
  904. #else
  905.     params = &uwcf->params;
  906. #endif

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

  911.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  912.         le.flushed = 1;

  914.         le.ip = params->lengths->elts;
  915.         le.request = r;

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

  919.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  920.             key_len = lcode(&le);

  922.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  923.             skip_empty = lcode(&le);

  925.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  926.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  927.             }
  928.             le.ip += sizeof(uintptr_t);

  930.             if (skip_empty && val_len == 0) {
  931.                 continue;
  932.             }

  934.             params_len += 2 + key_len + 2 + val_len;
  935.         }

  937.         len += params_len;
  938.     }

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

  942.         allocated = 0;
  943.         lowcase_key = NULL;

  945.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  946.             return NGX_ERROR;
  947.         }

  949.         if (params->number || r->headers_in.multi) {
  950.             n = 0;
  951.             part = &r->headers_in.headers.part;

  953.             while (part) {
  954.                 n += part->nelts;
  955.                 part = part->next;
  956.             }

  958.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  959.             if (ignored == NULL) {
  960.                 return NGX_ERROR;
  961.             }
  962.         }

  964.         part = &r->headers_in.headers.part;
  965.         header = part->elts;

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

  969.             if (i >= part->nelts) {
  970.                 if (part->next == NULL) {
  971.                     break;
  972.                 }

  974.                 part = part->next;
  975.                 header = part->elts;
  976.                 i = 0;
  977.             }

  979.             for (n = 0; n < header_params; n++) {
  980.                 if (&header[i] == ignored[n]) {
  981.                     goto next_length;
  982.                 }
  983.             }

  985.             if (params->number) {
  986.                 if (allocated < header[i].key.len) {
  987.                     allocated = header[i].key.len + 16;
  988.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  989.                     if (lowcase_key == NULL) {
  990.                         return NGX_ERROR;
  991.                     }
  992.                 }

  994.                 hash = 0;

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

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

  1002.                     } else if (ch == '-') {
  1003.                         ch = '_';
  1004.                     }

  1006.                     hash = ngx_hash(hash, ch);
  1007.                     lowcase_key[n] = ch;
  1008.                 }

  1010.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  1011.                     ignored[header_params++] = &header[i];
  1012.                     continue;
  1013.                 }
  1014.             }

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

  1019.             for (hn = header[i].next; hn; hn = hn->next) {
  1020.                 len += hn->value.len + 2;
  1021.                 ignored[header_params++] = hn;
  1022.             }

  1024.         next_length:

  1026.             continue;
  1027.         }
  1028.     }

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

  1032. #if 0
  1033.     /* allow custom uwsgi packet */
  1034.     if (len > 0 && len < 2) {
  1035.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1036.                       "uwsgi request is too little: %uz", len);
  1037.         return NGX_ERROR;
  1038.     }
  1039. #endif

  1041.     if (len > 65535) {
  1042.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1043.                       "uwsgi request is too big: %uz", len);
  1044.         return NGX_ERROR;
  1045.     }

  1047.     b = ngx_create_temp_buf(r->pool, len + 4);
  1048.     if (b == NULL) {
  1049.         return NGX_ERROR;
  1050.     }

  1052.     cl = ngx_alloc_chain_link(r->pool);
  1053.     if (cl == NULL) {
  1054.         return NGX_ERROR;
  1055.     }

  1057.     cl->buf = b;

  1059.     *b->last++ = (u_char) uwcf->modifier1;
  1060.     *b->last++ = (u_char) (len & 0xff);
  1061.     *b->last++ = (u_char) ((len >> 8) & 0xff);
  1062.     *b->last++ = (u_char) uwcf->modifier2;

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

  1067.         e.ip = params->values->elts;
  1068.         e.pos = b->last;
  1069.         e.end = b->last + params_len;
  1070.         e.request = r;
  1071.         e.flushed = 1;

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

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

  1077.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1078.             key_len = (u_char) lcode(&le);

  1080.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1081.             skip_empty = lcode(&le);

  1083.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1084.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1085.             }
  1086.             le.ip += sizeof(uintptr_t);

  1088.             if (skip_empty && val_len == 0) {
  1089.                 e.skip = 1;

  1091.                 while (*(uintptr_t *) e.ip) {
  1092.                     code = *(ngx_http_script_code_pt *) e.ip;
  1093.                     code((ngx_http_script_engine_t *) &e);
  1094.                 }
  1095.                 e.ip += sizeof(uintptr_t);

  1097.                 e.skip = 0;

  1099.                 continue;
  1100.             }

  1102.             if (ngx_http_script_check_length(&e, 2) != NGX_OK) {
  1103.                 return NGX_ERROR;
  1104.             }

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

  1109.             code = *(ngx_http_script_code_pt *) e.ip;
  1110.             code((ngx_http_script_engine_t *) &e);

  1112.             if (e.status) {
  1113.                 return NGX_ERROR;
  1114.             }

  1116.             if (ngx_http_script_check_length(&e, 2) != NGX_OK) {
  1117.                 return NGX_ERROR;
  1118.             }

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

  1123.             while (*(uintptr_t *) e.ip) {
  1124.                 code = *(ngx_http_script_code_pt *) e.ip;
  1125.                 code((ngx_http_script_engine_t *) &e);
  1126.             }

  1128.             if (e.status) {
  1129.                 return NGX_ERROR;
  1130.             }

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

  1134.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1135.                            "uwsgi param: \"%*s: %*s\"",
  1136.                            key_len, e.pos - (key_len + 2 + val_len),
  1137.                            val_len, e.pos - val_len);
  1138.         }

  1140.         if (e.pos != e.end) {
  1141.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1142.                           "uwsgi request length mismatch");
  1143.             return NGX_ERROR;
  1144.         }

  1146.         b->last = e.pos;
  1147.     }

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

  1151.         part = &r->headers_in.headers.part;
  1152.         header = part->elts;

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

  1156.             if (i >= part->nelts) {
  1157.                 if (part->next == NULL) {
  1158.                     break;
  1159.                 }

  1161.                 part = part->next;
  1162.                 header = part->elts;
  1163.                 i = 0;
  1164.             }

  1166.             for (n = 0; n < header_params; n++) {
  1167.                 if (&header[i] == ignored[n]) {
  1168.                     goto next_value;
  1169.                 }
  1170.             }

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

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

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

  1183.                 } else if (ch == '-') {
  1184.                     ch = '_';
  1185.                 }

  1187.                 *b->last++ = ch;
  1188.             }

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

  1192.             for (hn = header[i].next; hn; hn = hn->next) {
  1193.                 val_len += hn->value.len + 2;
  1194.             }

  1196.             *b->last++ = (u_char) (val_len & 0xff);
  1197.             *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1198.             b->last = ngx_copy(b->last, header[i].value.data,
  1199.                                header[i].value.len);

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

  1203.                 if (header[i].key.len == sizeof("Cookie") - 1
  1204.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1205.                                        sizeof("Cookie") - 1)
  1206.                        == 0)
  1207.                 {
  1208.                     sep = ';';

  1210.                 } else {
  1211.                     sep = ',';
  1212.                 }

  1214.                 for (hn = header[i].next; hn; hn = hn->next) {
  1215.                     *b->last++ = sep;
  1216.                     *b->last++ = ' ';
  1217.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1218.                 }
  1219.             }

  1221.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1222.                            "uwsgi param: \"%*s: %*s\"",
  1223.                            key_len, b->last - (key_len + 2 + val_len),
  1224.                            val_len, b->last - val_len);
  1225.         next_value:

  1227.             continue;
  1228.         }
  1229.     }

  1231.     b->last = ngx_copy(b->last, uwcf->uwsgi_string.data,
  1232.                        uwcf->uwsgi_string.len);

  1234.     if (r->request_body_no_buffering) {
  1235.         r->upstream->request_bufs = cl;

  1237.     } else if (uwcf->upstream.pass_request_body) {
  1238.         body = r->upstream->request_bufs;
  1239.         r->upstream->request_bufs = cl;

  1241.         while (body) {
  1242.             b = ngx_alloc_buf(r->pool);
  1243.             if (b == NULL) {
  1244.                 return NGX_ERROR;
  1245.             }

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

  1249.             cl->next = ngx_alloc_chain_link(r->pool);
  1250.             if (cl->next == NULL) {
  1251.                 return NGX_ERROR;
  1252.             }

  1254.             cl = cl->next;
  1255.             cl->buf = b;

  1257.             body = body->next;
  1258.         }

  1260.     } else {
  1261.         r->upstream->request_bufs = cl;
  1262.     }

  1264.     b->flush = 1;
  1265.     cl->next = NULL;

  1267.     return NGX_OK;
  1268. }


  1271. static ngx_int_t
  1272. ‌ngx_http_uwsgi_reinit_request(ngx_http_request_t *r)
  1273. {
  1274.     ngx_http_status_t  *status;

  1276.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1278.     if (status == NULL) {
  1279.         return NGX_OK;
  1280.     }

  1282.     status->code = 0;
  1283.     status->count = 0;
  1284.     status->start = NULL;
  1285.     status->end = NULL;

  1287.     r->upstream->process_header = ngx_http_uwsgi_process_status_line;
  1288.     r->state = 0;

  1290.     return NGX_OK;
  1291. }


  1294. static ngx_int_t
  1295. ‌ngx_http_uwsgi_process_status_line(ngx_http_request_t *r)
  1296. {
  1297.     size_t                 len;
  1298.     ngx_int_t              rc;
  1299.     ngx_http_status_t     *status;
  1300.     ngx_http_upstream_t   *u;

  1302.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1304.     if (status == NULL) {
  1305.         return NGX_ERROR;
  1306.     }

  1308.     u = r->upstream;

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

  1312.     if (rc == NGX_AGAIN) {
  1313.         return rc;
  1314.     }

  1316.     if (rc == NGX_ERROR) {
  1317.         u->process_header = ngx_http_uwsgi_process_header;
  1318.         u->buffer.pos = status->line_start;
  1319.         r->state = 0;
  1320.         return ngx_http_uwsgi_process_header(r);
  1321.     }

  1323.     if (u->state && u->state->status == 0) {
  1324.         u->state->status = status->code;
  1325.     }

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

  1329.     len = status->end - status->start;
  1330.     u->headers_in.status_line.len = len;

  1332.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1333.     if (u->headers_in.status_line.data == NULL) {
  1334.         return NGX_ERROR;
  1335.     }

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

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

  1343.     u->process_header = ngx_http_uwsgi_process_header;

  1345.     return ngx_http_uwsgi_process_header(r);
  1346. }


  1349. static ngx_int_t
  1350. ‌ngx_http_uwsgi_process_header(ngx_http_request_t *r)
  1351. {
  1352.     ngx_str_t                      *status_line;
  1353.     ngx_int_t                       rc, status;
  1354.     ngx_table_elt_t                *h;
  1355.     ngx_http_upstream_t            *u;
  1356.     ngx_http_upstream_header_t     *hh;
  1357.     ngx_http_upstream_main_conf_t  *umcf;

  1359.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1361.     for ( ;; ) {

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

  1365.         if (rc == NGX_OK) {

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

  1369.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1370.             if (h == NULL) {
  1371.                 return NGX_ERROR;
  1372.             }

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

  1376.             h->key.len = r->header_name_end - r->header_name_start;
  1377.             h->value.len = r->header_end - r->header_start;

  1379.             h->key.data = ngx_pnalloc(r->pool,
  1380.                                       h->key.len + 1 + h->value.len + 1
  1381.                                       + h->key.len);
  1382.             if (h->key.data == NULL) {
  1383.                 h->hash = 0;
  1384.                 return NGX_ERROR;
  1385.             }

  1387.             h->value.data = h->key.data + h->key.len + 1;
  1388.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1390.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1391.             h->key.data[h->key.len] = '\0';
  1392.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1393.             h->value.data[h->value.len] = '\0';

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

  1398.             } else {
  1399.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1400.             }

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

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

  1408.                 if (rc != NGX_OK) {
  1409.                     return rc;
  1410.                 }
  1411.             }

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

  1416.             continue;
  1417.         }

  1419.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1426.             u = r->upstream;

  1428.             if (u->headers_in.status_n) {
  1429.                 goto done;
  1430.             }

  1432.             if (u->headers_in.status) {
  1433.                 status_line = &u->headers_in.status->value;

  1435.                 status = ngx_atoi(status_line->data, 3);
  1436.                 if (status == NGX_ERROR) {
  1437.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1438.                                   "upstream sent invalid status \"%V\"",
  1439.                                   status_line);
  1440.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1441.                 }

  1443.                 u->headers_in.status_n = status;

  1445.                 if (status_line->len > 3) {
  1446.                     u->headers_in.status_line = *status_line;
  1447.                 }

  1449.             } else if (u->headers_in.location) {
  1450.                 u->headers_in.status_n = 302;
  1451.                 ngx_str_set(&u->headers_in.status_line,
  1452.                             "302 Moved Temporarily");

  1454.             } else {
  1455.                 u->headers_in.status_n = 200;
  1456.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1457.             }

  1459.             if (u->state && u->state->status == 0) {
  1460.                 u->state->status = u->headers_in.status_n;
  1461.             }

  1463.         done:

  1465.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1466.                 && r->headers_in.upgrade)
  1467.             {
  1468.                 u->upgrade = 1;
  1469.             }

  1471.             return NGX_OK;
  1472.         }

  1474.         if (rc == NGX_AGAIN) {
  1475.             return NGX_AGAIN;
  1476.         }

  1478.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1480.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1481.                       "upstream sent invalid header: \"%*s\\x%02xd...\"",
  1482.                       r->header_end - r->header_name_start,
  1483.                       r->header_name_start, *r->header_end);

  1485.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1486.     }
  1487. }


  1490. static ngx_int_t
  1491. ‌ngx_http_uwsgi_input_filter_init(void *data)
  1492. {
  1493.     ngx_http_request_t   *r = data;
  1494.     ngx_http_upstream_t  *u;

  1496.     u = r->upstream;

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

  1502.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1503.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  1504.     {
  1505.         u->pipe->length = 0;
  1506.         u->length = 0;

  1508.     } else if (r->method == NGX_HTTP_HEAD) {
  1509.         u->pipe->length = -1;
  1510.         u->length = -1;

  1512.     } else {
  1513.         u->pipe->length = u->headers_in.content_length_n;
  1514.         u->length = u->headers_in.content_length_n;
  1515.     }

  1517.     return NGX_OK;
  1518. }


  1521. static void
  1522. ‌ngx_http_uwsgi_abort_request(ngx_http_request_t *r)
  1523. {
  1524.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1525.                    "abort http uwsgi request");

  1527.     return;
  1528. }


  1531. static void
  1532. ‌ngx_http_uwsgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1533. {
  1534.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1535.                    "finalize http uwsgi request");

  1537.     return;
  1538. }


  1541. static void *
  1542. ‌ngx_http_uwsgi_create_main_conf(ngx_conf_t *cf)
  1543. {
  1544.     ngx_http_uwsgi_main_conf_t  *conf;

  1546.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_main_conf_t));
  1547.     if (conf == NULL) {
  1548.         return NULL;
  1549.     }

  1551. #if (NGX_HTTP_CACHE)
  1552.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1553.                        sizeof(ngx_http_file_cache_t *))
  1554.         != NGX_OK)
  1555.     {
  1556.         return NULL;
  1557.     }
  1558. #endif

  1560.     return conf;
  1561. }


  1564. static void *
  1565. ‌ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf)
  1566. {
  1567.     ngx_http_uwsgi_loc_conf_t  *conf;

  1569.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_loc_conf_t));
  1570.     if (conf == NULL) {
  1571.         return NULL;
  1572.     }

  1574.     /*
  1575.      * set by ngx_pcalloc():
  1576.      *
  1577.      *     conf->upstream.bufs.num = 0;
  1578.      *     conf->upstream.ignore_headers = 0;
  1579.      *     conf->upstream.next_upstream = 0;
  1580.      *     conf->upstream.cache_zone = NULL;
  1581.      *     conf->upstream.cache_use_stale = 0;
  1582.      *     conf->upstream.cache_methods = 0;
  1583.      *     conf->upstream.temp_path = NULL;
  1584.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  1585.      *     conf->upstream.store_lengths = NULL;
  1586.      *     conf->upstream.store_values = NULL;
  1587.      *
  1588.      *     conf->uwsgi_string = { 0, NULL };
  1589.      *     conf->ssl = 0;
  1590.      *     conf->ssl_protocols = 0;
  1591.      *     conf->ssl_ciphers = { 0, NULL };
  1592.      *     conf->ssl_trusted_certificate = { 0, NULL };
  1593.      *     conf->ssl_crl = { 0, NULL };
  1594.      */

  1596.     conf->modifier1 = NGX_CONF_UNSET_UINT;
  1597.     conf->modifier2 = NGX_CONF_UNSET_UINT;

  1599.     conf->upstream.store = NGX_CONF_UNSET;
  1600.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1601.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1602.     conf->upstream.buffering = NGX_CONF_UNSET;
  1603.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  1604.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1605.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1607.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  1608.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;
  1609.     conf->upstream.socket_rcvbuf = NGX_CONF_UNSET_SIZE;
  1610.     conf->upstream.socket_sndbuf = NGX_CONF_UNSET_SIZE;

  1612.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1613.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1614.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1615.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1617.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1618.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1619.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  1621.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1622.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1623.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1625.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1626.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1628. #if (NGX_HTTP_CACHE)
  1629.     conf->upstream.cache = NGX_CONF_UNSET;
  1630.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1631.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  1632.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1633.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1634.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1635.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1636.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1637.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1638.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1639.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  1640. #endif

  1642.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1643.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1645.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1647. #if (NGX_HTTP_SSL)
  1648.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  1649.     conf->upstream.ssl_name = NGX_CONF_UNSET_PTR;
  1650.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  1651.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  1652.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  1653.     conf->upstream.ssl_certificate = NGX_CONF_UNSET_PTR;
  1654.     conf->upstream.ssl_certificate_key = NGX_CONF_UNSET_PTR;
  1655.     conf->upstream.ssl_certificate_cache = NGX_CONF_UNSET_PTR;
  1656.     conf->upstream.ssl_passwords = NGX_CONF_UNSET_PTR;
  1657.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  1658. #endif

  1660.     /* "uwsgi_cyclic_temp_file" is disabled */
  1661.     conf->upstream.cyclic_temp_file = 0;

  1663.     conf->upstream.change_buffering = 1;

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

  1667.     return conf;
  1668. }


  1671. static char *
  1672. ‌ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1673. {
  1674.     ngx_http_uwsgi_loc_conf_t *prev = parent;
  1675.     ngx_http_uwsgi_loc_conf_t *conf = child;

  1677.     size_t                        size;
  1678.     ngx_int_t                     rc;
  1679.     ngx_hash_init_t               hash;
  1680.     ngx_http_core_loc_conf_t     *clcf;

  1682. #if (NGX_HTTP_CACHE)

  1684.     if (conf->upstream.store > 0) {
  1685.         conf->upstream.cache = 0;
  1686.     }

  1688.     if (conf->upstream.cache > 0) {
  1689.         conf->upstream.store = 0;
  1690.     }

  1692. #endif

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

  1697.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1698.         conf->upstream.store_values = prev->upstream.store_values;
  1699.     }

  1701.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1702.                               prev->upstream.store_access, 0600);

  1704.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1705.                               prev->upstream.next_upstream_tries, 0);

  1707.     ngx_conf_merge_value(conf->upstream.buffering,
  1708.                               prev->upstream.buffering, 1);

  1710.     ngx_conf_merge_value(conf->upstream.request_buffering,
  1711.                               prev->upstream.request_buffering, 1);

  1713.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1714.                               prev->upstream.ignore_client_abort, 0);

  1716.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1717.                               prev->upstream.force_ranges, 0);

  1719.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1720.                               prev->upstream.local, NULL);

  1722.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  1723.                               prev->upstream.socket_keepalive, 0);

  1725.     ngx_conf_merge_size_value(conf->upstream.socket_rcvbuf,
  1726.                               prev->upstream.socket_rcvbuf, 0);

  1728.     ngx_conf_merge_size_value(conf->upstream.socket_sndbuf,
  1729.                               prev->upstream.socket_sndbuf, 0);

  1731.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1732.                               prev->upstream.connect_timeout, 60000);

  1734.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1735.                               prev->upstream.send_timeout, 60000);

  1737.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1738.                               prev->upstream.read_timeout, 60000);

  1740.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1741.                               prev->upstream.next_upstream_timeout, 0);

  1743.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1744.                               prev->upstream.send_lowat, 0);

  1746.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1747.                               prev->upstream.buffer_size,
  1748.                               (size_t) ngx_pagesize);

  1750.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  1751.                               prev->upstream.limit_rate, NULL);


  1754.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1755.                               8, ngx_pagesize);

  1757.     if (conf->upstream.bufs.num < 2) {
  1758.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1759.                            "there must be at least 2 \"uwsgi_buffers\"");
  1760.         return NGX_CONF_ERROR;
  1761.     }


  1764.     size = conf->upstream.buffer_size;
  1765.     if (size < conf->upstream.bufs.size) {
  1766.         size = conf->upstream.bufs.size;
  1767.     }


  1770.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1771.                               prev->upstream.busy_buffers_size_conf,
  1772.                               NGX_CONF_UNSET_SIZE);

  1774.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1775.         conf->upstream.busy_buffers_size = 2 * size;
  1776.     } else {
  1777.         conf->upstream.busy_buffers_size =
  1778.             conf->upstream.busy_buffers_size_conf;
  1779.     }

  1781.     if (conf->upstream.busy_buffers_size < size) {
  1782.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1783.             "\"uwsgi_busy_buffers_size\" must be equal to or greater "
  1784.             "than the maximum of the value of \"uwsgi_buffer_size\" and "
  1785.             "one of the \"uwsgi_buffers\"");

  1787.         return NGX_CONF_ERROR;
  1788.     }

  1790.     if (conf->upstream.busy_buffers_size
  1791.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1792.     {
  1793.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1794.             "\"uwsgi_busy_buffers_size\" must be less than "
  1795.             "the size of all \"uwsgi_buffers\" minus one buffer");

  1797.         return NGX_CONF_ERROR;
  1798.     }


  1801.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1802.                               prev->upstream.temp_file_write_size_conf,
  1803.                               NGX_CONF_UNSET_SIZE);

  1805.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1806.         conf->upstream.temp_file_write_size = 2 * size;
  1807.     } else {
  1808.         conf->upstream.temp_file_write_size =
  1809.             conf->upstream.temp_file_write_size_conf;
  1810.     }

  1812.     if (conf->upstream.temp_file_write_size < size) {
  1813.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1814.             "\"uwsgi_temp_file_write_size\" must be equal to or greater than "
  1815.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1816.             "one of the \"uwsgi_buffers\"");

  1818.         return NGX_CONF_ERROR;
  1819.     }


  1822.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1823.                               prev->upstream.max_temp_file_size_conf,
  1824.                               NGX_CONF_UNSET_SIZE);

  1826.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1827.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1828.     } else {
  1829.         conf->upstream.max_temp_file_size =
  1830.             conf->upstream.max_temp_file_size_conf;
  1831.     }

  1833.     if (conf->upstream.max_temp_file_size != 0
  1834.         && conf->upstream.max_temp_file_size < size)
  1835.     {
  1836.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1837.             "\"uwsgi_max_temp_file_size\" must be equal to zero to disable "
  1838.             "temporary files usage or must be equal to or greater than "
  1839.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1840.             "one of the \"uwsgi_buffers\"");

  1842.         return NGX_CONF_ERROR;
  1843.     }


  1846.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1847.                                  prev->upstream.ignore_headers,
  1848.                                  NGX_CONF_BITMASK_SET);


  1851.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1852.                                  prev->upstream.next_upstream,
  1853.                                  (NGX_CONF_BITMASK_SET
  1854.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1855.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

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

  1862.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1863.                                   prev->upstream.temp_path,
  1864.                                   &ngx_http_uwsgi_temp_path)
  1865.         != NGX_CONF_OK)
  1866.     {
  1867.         return NGX_CONF_ERROR;
  1868.     }

  1870. #if (NGX_HTTP_CACHE)

  1872.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1873.         ngx_conf_merge_value(conf->upstream.cache,
  1874.                               prev->upstream.cache, 0);

  1876.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1877.         conf->upstream.cache_value = prev->upstream.cache_value;
  1878.     }

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

  1883.         shm_zone = conf->upstream.cache_zone;

  1885.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1886.                            "\"uwsgi_cache\" zone \"%V\" is unknown",
  1887.                            &shm_zone->shm.name);

  1889.         return NGX_CONF_ERROR;
  1890.     }

  1892.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1893.                               prev->upstream.cache_min_uses, 1);

  1895.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  1896.                               prev->upstream.cache_max_range_offset,
  1897.                               NGX_MAX_OFF_T_VALUE);

  1899.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1900.                               prev->upstream.cache_use_stale,
  1901.                               (NGX_CONF_BITMASK_SET
  1902.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1904.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1905.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1906.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1907.     }

  1909.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1910.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1911.     }

  1913.     if (conf->upstream.cache_methods == 0) {
  1914.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1915.     }

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

  1919.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1920.                              prev->upstream.cache_bypass, NULL);

  1922.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1923.                              prev->upstream.no_cache, NULL);

  1925.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1926.                              prev->upstream.cache_valid, NULL);

  1928.     if (conf->cache_key.value.data == NULL) {
  1929.         conf->cache_key = prev->cache_key;
  1930.     }

  1932.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1933.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1934.                            "no \"uwsgi_cache_key\" for \"uwsgi_cache\"");
  1935.     }

  1937.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1938.                               prev->upstream.cache_lock, 0);

  1940.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1941.                               prev->upstream.cache_lock_timeout, 5000);

  1943.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1944.                               prev->upstream.cache_lock_age, 5000);

  1946.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1947.                               prev->upstream.cache_revalidate, 0);

  1949.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  1950.                               prev->upstream.cache_background_update, 0);

  1952. #endif

  1954.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1955.                          prev->upstream.pass_request_headers, 1);
  1956.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1957.                          prev->upstream.pass_request_body, 1);

  1959.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1960.                          prev->upstream.intercept_errors, 0);

  1962. #if (NGX_HTTP_SSL)

  1964.     if (ngx_http_uwsgi_merge_ssl(cf, conf, prev) != NGX_OK) {
  1965.         return NGX_CONF_ERROR;
  1966.     }

  1968.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  1969.                               prev->upstream.ssl_session_reuse, 1);

  1971.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  1972.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  1974.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  1975.                              "DEFAULT");

  1977.     ngx_conf_merge_ptr_value(conf->upstream.ssl_name,
  1978.                               prev->upstream.ssl_name, NULL);
  1979.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  1980.                               prev->upstream.ssl_server_name, 0);
  1981.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  1982.                               prev->upstream.ssl_verify, 0);
  1983.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  1984.                               prev->ssl_verify_depth, 1);
  1985.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  1986.                               prev->ssl_trusted_certificate, "");
  1987.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  1989.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate,
  1990.                               prev->upstream.ssl_certificate, NULL);
  1991.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_key,
  1992.                               prev->upstream.ssl_certificate_key, NULL);
  1993.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_cache,
  1994.                               prev->upstream.ssl_certificate_cache, NULL);

  1996.     if (ngx_http_upstream_merge_ssl_passwords(cf, &conf->upstream,
  1997.                                               &prev->upstream)
  1998.         != NGX_OK)
  1999.     {
  2000.         return NGX_CONF_ERROR;
  2001.     }

  2003.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  2004.                               prev->ssl_conf_commands, NULL);

  2006.     if (conf->ssl && ngx_http_uwsgi_set_ssl(cf, conf) != NGX_OK) {
  2007.         return NGX_CONF_ERROR;
  2008.     }

  2010. #endif

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

  2014.     hash.max_size = 512;
  2015.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  2016.     hash.name = "uwsgi_hide_headers_hash";

  2018.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  2019.             &prev->upstream, ngx_http_uwsgi_hide_headers, &hash)
  2020.         != NGX_OK)
  2021.     {
  2022.         return NGX_CONF_ERROR;
  2023.     }

  2025.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  2027.     if (clcf->noname
  2028.         && conf->upstream.upstream == NULL && conf->uwsgi_lengths == NULL)
  2029.     {
  2030.         conf->upstream.upstream = prev->upstream.upstream;

  2032.         conf->uwsgi_lengths = prev->uwsgi_lengths;
  2033.         conf->uwsgi_values = prev->uwsgi_values;

  2035. #if (NGX_HTTP_SSL)
  2036.         conf->ssl = prev->ssl;
  2037. #endif
  2038.     }

  2040.     if (clcf->lmt_excpt && clcf->handler == NULL
  2041.         && (conf->upstream.upstream || conf->uwsgi_lengths))
  2042.     {
  2043.         clcf->handler = ngx_http_uwsgi_handler;
  2044.     }

  2046.     ngx_conf_merge_uint_value(conf->modifier1, prev->modifier1, 0);
  2047.     ngx_conf_merge_uint_value(conf->modifier2, prev->modifier2, 0);

  2049.     if (conf->params_source == NULL) {
  2050.         conf->params = prev->params;
  2051. #if (NGX_HTTP_CACHE)
  2052.         conf->params_cache = prev->params_cache;
  2053. #endif
  2054.         conf->params_source = prev->params_source;
  2055.     }

  2057.     rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params,
  2058.                                     ngx_http_uwsgi_headers);
  2059.     if (rc != NGX_OK) {
  2060.         return NGX_CONF_ERROR;
  2061.     }

  2063. #if (NGX_HTTP_CACHE)

  2065.     if (conf->upstream.cache) {
  2066.         rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params_cache,
  2067.                                         ngx_http_uwsgi_cache_headers);
  2068.         if (rc != NGX_OK) {
  2069.             return NGX_CONF_ERROR;
  2070.         }
  2071.     }

  2073. #endif

  2075.     /*
  2076.      * special handling to preserve conf->params in the "http" section
  2077.      * to inherit it to all servers
  2078.      */

  2080.     if (prev->params.hash.buckets == NULL
  2081.         && conf->params_source == prev->params_source)
  2082.     {
  2083.         prev->params = conf->params;
  2084. #if (NGX_HTTP_CACHE)
  2085.         prev->params_cache = conf->params_cache;
  2086. #endif
  2087.     }

  2089.     return NGX_CONF_OK;
  2090. }


  2093. static ngx_int_t
  2094. ‌ngx_http_uwsgi_init_params(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  2095.     ngx_http_uwsgi_params_t *params, ngx_keyval_t *default_params)
  2096. {
  2097.     u_char                       *p;
  2098.     size_t                        size;
  2099.     uintptr_t                    *code;
  2100.     ngx_uint_t                    i, nsrc;
  2101.     ngx_array_t                   headers_names, params_merged;
  2102.     ngx_keyval_t                 *h;
  2103.     ngx_hash_key_t               *hk;
  2104.     ngx_hash_init_t               hash;
  2105.     ngx_http_upstream_param_t    *src, *s;
  2106.     ngx_http_script_compile_t     sc;
  2107.     ngx_http_script_copy_code_t  *copy;

  2109.     if (params->hash.buckets) {
  2110.         return NGX_OK;
  2111.     }

  2113.     if (conf->params_source == NULL && default_params == NULL) {
  2114.         params->hash.buckets = (void *) 1;
  2115.         return NGX_OK;
  2116.     }

  2118.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  2119.     if (params->lengths == NULL) {
  2120.         return NGX_ERROR;
  2121.     }

  2123.     params->values = ngx_array_create(cf->pool, 512, 1);
  2124.     if (params->values == NULL) {
  2125.         return NGX_ERROR;
  2126.     }

  2128.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  2129.         != NGX_OK)
  2130.     {
  2131.         return NGX_ERROR;
  2132.     }

  2134.     if (conf->params_source) {
  2135.         src = conf->params_source->elts;
  2136.         nsrc = conf->params_source->nelts;

  2138.     } else {
  2139.         src = NULL;
  2140.         nsrc = 0;
  2141.     }

  2143.     if (default_params) {
  2144.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  2145.                            sizeof(ngx_http_upstream_param_t))
  2146.             != NGX_OK)
  2147.         {
  2148.             return NGX_ERROR;
  2149.         }

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

  2153.             s = ngx_array_push(&params_merged);
  2154.             if (s == NULL) {
  2155.                 return NGX_ERROR;
  2156.             }

  2158.             *s = src[i];
  2159.         }

  2161.         h = default_params;

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

  2165.             src = params_merged.elts;
  2166.             nsrc = params_merged.nelts;

  2168.             for (i = 0; i < nsrc; i++) {
  2169.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  2170.                     goto next;
  2171.                 }
  2172.             }

  2174.             s = ngx_array_push(&params_merged);
  2175.             if (s == NULL) {
  2176.                 return NGX_ERROR;
  2177.             }

  2179.             s->key = h->key;
  2180.             s->value = h->value;
  2181.             s->skip_empty = 1;

  2183.         next:

  2185.             h++;
  2186.         }

  2188.         src = params_merged.elts;
  2189.         nsrc = params_merged.nelts;
  2190.     }

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

  2194.         if (src[i].key.len > sizeof("HTTP_") - 1
  2195.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  2196.         {
  2197.             hk = ngx_array_push(&headers_names);
  2198.             if (hk == NULL) {
  2199.                 return NGX_ERROR;
  2200.             }

  2202.             hk->key.len = src[i].key.len - 5;
  2203.             hk->key.data = src[i].key.data + 5;
  2204.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  2205.             hk->value = (void *) 1;

  2207.             if (src[i].value.len == 0) {
  2208.                 continue;
  2209.             }
  2210.         }

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

  2218.         copy->code = (ngx_http_script_code_pt) (void *)
  2219.                                                  ngx_http_script_copy_len_code;
  2220.         copy->len = src[i].key.len;

  2222.         copy = ngx_array_push_n(params->lengths,
  2223.                                 sizeof(ngx_http_script_copy_code_t));
  2224.         if (copy == NULL) {
  2225.             return NGX_ERROR;
  2226.         }

  2228.         copy->code = (ngx_http_script_code_pt) (void *)
  2229.                                                  ngx_http_script_copy_len_code;
  2230.         copy->len = src[i].skip_empty;


  2233.         size = (sizeof(ngx_http_script_copy_code_t)
  2234.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  2235.                & ~(sizeof(uintptr_t) - 1);

  2237.         copy = ngx_array_push_n(params->values, size);
  2238.         if (copy == NULL) {
  2239.             return NGX_ERROR;
  2240.         }

  2242.         copy->code = ngx_http_script_copy_code;
  2243.         copy->len = src[i].key.len;

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


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

  2251.         sc.cf = cf;
  2252.         sc.source = &src[i].value;
  2253.         sc.flushes = &params->flushes;
  2254.         sc.lengths = &params->lengths;
  2255.         sc.values = &params->values;

  2257.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2258.             return NGX_ERROR;
  2259.         }

  2261.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  2262.         if (code == NULL) {
  2263.             return NGX_ERROR;
  2264.         }

  2266.         *code = (uintptr_t) NULL;


  2269.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  2270.         if (code == NULL) {
  2271.             return NGX_ERROR;
  2272.         }

  2274.         *code = (uintptr_t) NULL;
  2275.     }

  2277.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  2278.     if (code == NULL) {
  2279.         return NGX_ERROR;
  2280.     }

  2282.     *code = (uintptr_t) NULL;

  2284.     params->number = headers_names.nelts;

  2286.     hash.hash = &params->hash;
  2287.     hash.key = ngx_hash_key_lc;
  2288.     hash.max_size = 512;
  2289.     hash.bucket_size = 64;
  2290.     hash.name = "uwsgi_params_hash";
  2291.     hash.pool = cf->pool;
  2292.     hash.temp_pool = NULL;

  2294.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  2295. }


  2298. static char *
  2299. ‌ngx_http_uwsgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2300. {
  2301.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2303.     size_t                      add;
  2304.     ngx_url_t                   u;
  2305.     ngx_str_t                  *value, *url;
  2306.     ngx_uint_t                  n;
  2307.     ngx_http_core_loc_conf_t   *clcf;
  2308.     ngx_http_script_compile_t   sc;

  2310.     if (uwcf->upstream.upstream || uwcf->uwsgi_lengths) {
  2311.         return "is duplicate";
  2312.     }

  2314.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  2315.     clcf->handler = ngx_http_uwsgi_handler;

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

  2319.     url = &value[1];

  2321.     n = ngx_http_script_variables_count(url);

  2323.     if (n) {

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

  2327.         sc.cf = cf;
  2328.         sc.source = url;
  2329.         sc.lengths = &uwcf->uwsgi_lengths;
  2330.         sc.values = &uwcf->uwsgi_values;
  2331.         sc.variables = n;
  2332.         sc.complete_lengths = 1;
  2333.         sc.complete_values = 1;

  2335.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2336.             return NGX_CONF_ERROR;
  2337.         }

  2339. #if (NGX_HTTP_SSL)
  2340.         uwcf->ssl = 1;
  2341. #endif

  2343.         return NGX_CONF_OK;
  2344.     }

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

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

  2351. #if (NGX_HTTP_SSL)
  2352.         add = 9;
  2353.         uwcf->ssl = 1;
  2354. #else
  2355.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2356.                            "suwsgi protocol requires SSL support");
  2357.         return NGX_CONF_ERROR;
  2358. #endif

  2360.     } else {
  2361.         add = 0;
  2362.     }

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

  2366.     u.url.len = url->len - add;
  2367.     u.url.data = url->data + add;
  2368.     u.no_resolve = 1;

  2370.     uwcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  2371.     if (uwcf->upstream.upstream == NULL) {
  2372.         return NGX_CONF_ERROR;
  2373.     }

  2375.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  2376.         clcf->auto_redirect = 1;
  2377.     }

  2379.     return NGX_CONF_OK;
  2380. }


  2383. static char *
  2384. ‌ngx_http_uwsgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2385. {
  2386.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2388.     ngx_str_t                  *value;
  2389.     ngx_http_script_compile_t   sc;

  2391.     if (uwcf->upstream.store != NGX_CONF_UNSET) {
  2392.         return "is duplicate";
  2393.     }

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

  2397.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2398.         uwcf->upstream.store = 0;
  2399.         return NGX_CONF_OK;
  2400.     }

  2402.     if (value[1].len == 0) {
  2403.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  2404.         return NGX_CONF_ERROR;
  2405.     }

  2407. #if (NGX_HTTP_CACHE)

  2409.     if (uwcf->upstream.cache > 0) {
  2410.         return "is incompatible with \"uwsgi_cache\"";
  2411.     }

  2413. #endif

  2415.     uwcf->upstream.store = 1;

  2417.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2418.         return NGX_CONF_OK;
  2419.     }

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

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

  2426.     sc.cf = cf;
  2427.     sc.source = &value[1];
  2428.     sc.lengths = &uwcf->upstream.store_lengths;
  2429.     sc.values = &uwcf->upstream.store_values;
  2430.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2431.     sc.complete_lengths = 1;
  2432.     sc.complete_values = 1;

  2434.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2435.         return NGX_CONF_ERROR;
  2436.     }

  2438.     return NGX_CONF_OK;
  2439. }


  2442. #if (NGX_HTTP_CACHE)

  2444. static char *
  2445. ‌ngx_http_uwsgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2446. {
  2447.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2449.     ngx_str_t                         *value;
  2450.     ngx_http_complex_value_t           cv;
  2451.     ngx_http_compile_complex_value_t   ccv;

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

  2455.     if (uwcf->upstream.cache != NGX_CONF_UNSET) {
  2456.         return "is duplicate";
  2457.     }

  2459.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2460.         uwcf->upstream.cache = 0;
  2461.         return NGX_CONF_OK;
  2462.     }

  2464.     if (uwcf->upstream.store > 0) {
  2465.         return "is incompatible with \"uwsgi_store\"";
  2466.     }

  2468.     uwcf->upstream.cache = 1;

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

  2472.     ccv.cf = cf;
  2473.     ccv.value = &value[1];
  2474.     ccv.complex_value = &cv;

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

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

  2482.         uwcf->upstream.cache_value = ngx_palloc(cf->pool,
  2483.                                              sizeof(ngx_http_complex_value_t));
  2484.         if (uwcf->upstream.cache_value == NULL) {
  2485.             return NGX_CONF_ERROR;
  2486.         }

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

  2490.         return NGX_CONF_OK;
  2491.     }

  2493.     uwcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2494.                                                       &ngx_http_uwsgi_module);
  2495.     if (uwcf->upstream.cache_zone == NULL) {
  2496.         return NGX_CONF_ERROR;
  2497.     }

  2499.     return NGX_CONF_OK;
  2500. }


  2503. static char *
  2504. ‌ngx_http_uwsgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2505. {
  2506.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2508.     ngx_str_t                         *value;
  2509.     ngx_http_compile_complex_value_t   ccv;

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

  2513.     if (uwcf->cache_key.value.data) {
  2514.         return "is duplicate";
  2515.     }

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

  2519.     ccv.cf = cf;
  2520.     ccv.value = &value[1];
  2521.     ccv.complex_value = &uwcf->cache_key;

  2523.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2524.         return NGX_CONF_ERROR;
  2525.     }

  2527.     return NGX_CONF_OK;
  2528. }

  2530. #endif


  2533. #if (NGX_HTTP_SSL)

  2535. static char *
  2536. ‌ngx_http_uwsgi_ssl_certificate_cache(ngx_conf_t *cf, ngx_command_t *cmd,
  2537.     void *conf)
  2538. {
  2539.     ngx_http_uwsgi_loc_conf_t *plcf = conf;

  2541.     time_t       inactive, valid;
  2542.     ngx_str_t   *value, s;
  2543.     ngx_int_t    max;
  2544.     ngx_uint_t   i;

  2546.     if (plcf->upstream.ssl_certificate_cache != NGX_CONF_UNSET_PTR) {
  2547.         return "is duplicate";
  2548.     }

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

  2552.     max = 0;
  2553.     inactive = 10;
  2554.     valid = 60;

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

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

  2560.             max = ngx_atoi(value[i].data + 4, value[i].len - 4);
  2561.             if (max <= 0) {
  2562.                 goto failed;
  2563.             }

  2565.             continue;
  2566.         }

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

  2570.             s.len = value[i].len - 9;
  2571.             s.data = value[i].data + 9;

  2573.             inactive = ngx_parse_time(&s, 1);
  2574.             if (inactive == (time_t) NGX_ERROR) {
  2575.                 goto failed;
  2576.             }

  2578.             continue;
  2579.         }

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

  2583.             s.len = value[i].len - 6;
  2584.             s.data = value[i].data + 6;

  2586.             valid = ngx_parse_time(&s, 1);
  2587.             if (valid == (time_t) NGX_ERROR) {
  2588.                 goto failed;
  2589.             }

  2591.             continue;
  2592.         }

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

  2596.             plcf->upstream.ssl_certificate_cache = NULL;

  2598.             continue;
  2599.         }

  2601.     failed:

  2603.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2604.                            "invalid parameter \"%V\"", &value[i]);
  2605.         return NGX_CONF_ERROR;
  2606.     }

  2608.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  2609.         return NGX_CONF_OK;
  2610.     }

  2612.     if (max == 0) {
  2613.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2614.                            "\"uwsgi_ssl_certificate_cache\" must have "
  2615.                            "the \"max\" parameter");
  2616.         return NGX_CONF_ERROR;
  2617.     }

  2619.     plcf->upstream.ssl_certificate_cache = ngx_ssl_cache_init(cf->pool, max,
  2620.                                                               valid, inactive);
  2621.     if (plcf->upstream.ssl_certificate_cache == NULL) {
  2622.         return NGX_CONF_ERROR;
  2623.     }

  2625.     return NGX_CONF_OK;
  2626. }


  2629. static char *
  2630. ‌ngx_http_uwsgi_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2631. {
  2632.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2634.     ngx_str_t  *value;

  2636.     if (uwcf->upstream.ssl_passwords != NGX_CONF_UNSET_PTR) {
  2637.         return "is duplicate";
  2638.     }

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

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

  2644.     if (uwcf->upstream.ssl_passwords == NULL) {
  2645.         return NGX_CONF_ERROR;
  2646.     }

  2648.     return NGX_CONF_OK;
  2649. }


  2652. static char *
  2653. ‌ngx_http_uwsgi_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  2654. {
  2655. #ifndef SSL_CONF_FLAG_FILE
  2656.     return "is not supported on this platform";
  2657. #else
  2658.     return NGX_CONF_OK;
  2659. #endif
  2660. }


  2663. static ngx_int_t
  2664. ‌ngx_http_uwsgi_merge_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  2665.     ngx_http_uwsgi_loc_conf_t *prev)
  2666. {
  2667.     ngx_uint_t  preserve;

  2669.     if (conf->ssl_protocols == 0
  2670.         && conf->ssl_ciphers.data == NULL
  2671.         && conf->upstream.ssl_certificate == NGX_CONF_UNSET_PTR
  2672.         && conf->upstream.ssl_certificate_key == NGX_CONF_UNSET_PTR
  2673.         && conf->upstream.ssl_passwords == NGX_CONF_UNSET_PTR
  2674.         && conf->upstream.ssl_verify == NGX_CONF_UNSET
  2675.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  2676.         && conf->ssl_trusted_certificate.data == NULL
  2677.         && conf->ssl_crl.data == NULL
  2678.         && conf->upstream.ssl_session_reuse == NGX_CONF_UNSET
  2679.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  2680.     {
  2681.         if (prev->upstream.ssl) {
  2682.             conf->upstream.ssl = prev->upstream.ssl;
  2683.             return NGX_OK;
  2684.         }

  2686.         preserve = 1;

  2688.     } else {
  2689.         preserve = 0;
  2690.     }

  2692.     conf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2693.     if (conf->upstream.ssl == NULL) {
  2694.         return NGX_ERROR;
  2695.     }

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

  2699.     /*
  2700.      * special handling to preserve conf->upstream.ssl
  2701.      * in the "http" section to inherit it to all servers
  2702.      */

  2704.     if (preserve) {
  2705.         prev->upstream.ssl = conf->upstream.ssl;
  2706.     }

  2708.     return NGX_OK;
  2709. }


  2712. static ngx_int_t
  2713. ‌ngx_http_uwsgi_set_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *uwcf)
  2714. {
  2715.     ngx_pool_cleanup_t  *cln;

  2717.     if (uwcf->upstream.ssl->ctx) {
  2718.         return NGX_OK;
  2719.     }

  2721.     if (ngx_ssl_create(uwcf->upstream.ssl, uwcf->ssl_protocols, NULL)
  2722.         != NGX_OK)
  2723.     {
  2724.         return NGX_ERROR;
  2725.     }

  2727.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2728.     if (cln == NULL) {
  2729.         ngx_ssl_cleanup_ctx(uwcf->upstream.ssl);
  2730.         return NGX_ERROR;
  2731.     }

  2733.     cln->handler = ngx_ssl_cleanup_ctx;
  2734.     cln->data = uwcf->upstream.ssl;

  2736.     if (ngx_ssl_ciphers(cf, uwcf->upstream.ssl, &uwcf->ssl_ciphers, 0)
  2737.         != NGX_OK)
  2738.     {
  2739.         return NGX_ERROR;
  2740.     }

  2742.     if (uwcf->upstream.ssl_certificate
  2743.         && uwcf->upstream.ssl_certificate->value.len)
  2744.     {
  2745.         if (uwcf->upstream.ssl_certificate_key == NULL) {
  2746.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2747.                           "no \"uwsgi_ssl_certificate_key\" is defined "
  2748.                           "for certificate \"%V\"",
  2749.                           &uwcf->upstream.ssl_certificate->value);
  2750.             return NGX_ERROR;
  2751.         }

  2753.         if (uwcf->upstream.ssl_certificate->lengths == NULL
  2754.             && uwcf->upstream.ssl_certificate_key->lengths == NULL)
  2755.         {
  2756.             if (ngx_ssl_certificate(cf, uwcf->upstream.ssl,
  2757.                                     &uwcf->upstream.ssl_certificate->value,
  2758.                                     &uwcf->upstream.ssl_certificate_key->value,
  2759.                                     uwcf->upstream.ssl_passwords)
  2760.                 != NGX_OK)
  2761.             {
  2762.                 return NGX_ERROR;
  2763.             }
  2764.         }
  2765.     }

  2767.     if (uwcf->upstream.ssl_verify) {
  2768.         if (uwcf->ssl_trusted_certificate.len == 0) {
  2769.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2770.                       "no uwsgi_ssl_trusted_certificate for uwsgi_ssl_verify");
  2771.             return NGX_ERROR;
  2772.         }

  2774.         if (ngx_ssl_trusted_certificate(cf, uwcf->upstream.ssl,
  2775.                                         &uwcf->ssl_trusted_certificate,
  2776.                                         uwcf->ssl_verify_depth)
  2777.             != NGX_OK)
  2778.         {
  2779.             return NGX_ERROR;
  2780.         }

  2782.         if (ngx_ssl_crl(cf, uwcf->upstream.ssl, &uwcf->ssl_crl) != NGX_OK) {
  2783.             return NGX_ERROR;
  2784.         }
  2785.     }

  2787.     if (ngx_ssl_client_session_cache(cf, uwcf->upstream.ssl,
  2788.                                      uwcf->upstream.ssl_session_reuse)
  2789.         != NGX_OK)
  2790.     {
  2791.         return NGX_ERROR;
  2792.     }

  2794.     if (ngx_ssl_conf_commands(cf, uwcf->upstream.ssl, uwcf->ssl_conf_commands)
  2795.         != NGX_OK)
  2796.     {
  2797.         return NGX_ERROR;
  2798.     }

  2800.     return NGX_OK;
  2801. }

  2803. #endif

One Level Up Top Level