One Level Up Top Level

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

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_password_file(ngx_conf_t *cf,
  96.     ngx_command_t *cmd, void *conf);
  97. static char *ngx_http_uwsgi_ssl_conf_command_check(ngx_conf_t *cf, void *post,
  98.     void *data);
  99. static ngx_int_t ngx_http_uwsgi_merge_ssl(ngx_conf_t *cf,
  100.     ngx_http_uwsgi_loc_conf_t *conf, ngx_http_uwsgi_loc_conf_t *prev);
  101. static ngx_int_t ngx_http_uwsgi_set_ssl(ngx_conf_t *cf,
  102.     ngx_http_uwsgi_loc_conf_t *uwcf);
  103. #endif


  106. ‌static ngx_conf_num_bounds_t  ngx_http_uwsgi_modifier_bounds = {
  107.     ngx_conf_check_num_bounds, 0, 255
  108. };


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


  127. #if (NGX_HTTP_SSL)

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

  139. ‌static ngx_conf_post_t  ngx_http_uwsgi_ssl_conf_command_post =
  140.     { ngx_http_uwsgi_ssl_conf_command_check };

  142. #endif


  145. ‌ngx_module_t  ngx_http_uwsgi_module;


  148. ‌static ngx_command_t ngx_http_uwsgi_commands[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  297. #if (NGX_HTTP_CACHE)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  404. #endif

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

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

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

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

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

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

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

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

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

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

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

  483. #if (NGX_HTTP_SSL)

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

  492.     { ngx_string("uwsgi_ssl_protocols"),
  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, ssl_protocols),
  497.       &ngx_http_uwsgi_ssl_protocols },

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

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

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

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

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

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

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

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

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

  562.     { ngx_string("uwsgi_ssl_password_file"),
  563.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  564.       ngx_http_uwsgi_ssl_password_file,
  565.       NGX_HTTP_LOC_CONF_OFFSET,
  566.       0,
  567.       NULL },

  569.     { ngx_string("uwsgi_ssl_conf_command"),
  570.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  571.       ngx_conf_set_keyval_slot,
  572.       NGX_HTTP_LOC_CONF_OFFSET,
  573.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_conf_commands),
  574.       &ngx_http_uwsgi_ssl_conf_command_post },

  576. #endif

  578.       ngx_null_command
  579. };


  582. ‌static ngx_http_module_t ngx_http_uwsgi_module_ctx = {
  583.     NULL,                                  /* preconfiguration */
  584.     NULL,                                  /* postconfiguration */

  586.     ngx_http_uwsgi_create_main_conf,       /* create main configuration */
  587.     NULL,                                  /* init main configuration */

  589.     NULL,                                  /* create server configuration */
  590.     NULL,                                  /* merge server configuration */

  592.     ngx_http_uwsgi_create_loc_conf,        /* create location configuration */
  593.     ngx_http_uwsgi_merge_loc_conf          /* merge location configuration */
  594. };


  597. ‌ngx_module_t ngx_http_uwsgi_module = {
  598.     NGX_MODULE_V1,
  599.     &ngx_http_uwsgi_module_ctx,            /* module context */
  600.     ngx_http_uwsgi_commands,               /* module directives */
  601.     NGX_HTTP_MODULE,                       /* module type */
  602.     NULL,                                  /* init master */
  603.     NULL,                                  /* init module */
  604.     NULL,                                  /* init process */
  605.     NULL,                                  /* init thread */
  606.     NULL,                                  /* exit thread */
  607.     NULL,                                  /* exit process */
  608.     NULL,                                  /* exit master */
  609.     NGX_MODULE_V1_PADDING
  610. };


  613. ‌static ngx_str_t ngx_http_uwsgi_hide_headers[] = {
  614.     ngx_string("X-Accel-Expires"),
  615.     ngx_string("X-Accel-Redirect"),
  616.     ngx_string("X-Accel-Limit-Rate"),
  617.     ngx_string("X-Accel-Buffering"),
  618.     ngx_string("X-Accel-Charset"),
  619.     ngx_null_string
  620. };


  623. #if (NGX_HTTP_CACHE)

  625. ‌static ngx_keyval_t  ngx_http_uwsgi_cache_headers[] = {
  626.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  627.       ngx_string("$upstream_cache_last_modified") },
  628.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  629.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  630.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  631.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  632.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  633.     { ngx_null_string, ngx_null_string }
  634. };

  636. #endif


  639. ‌static ngx_path_init_t ngx_http_uwsgi_temp_path = {
  640.     ngx_string(NGX_HTTP_UWSGI_TEMP_PATH), { 1, 2, 0 }
  641. };


  644. static ngx_int_t
  645. ‌ngx_http_uwsgi_handler(ngx_http_request_t *r)
  646. {
  647.     ngx_int_t                    rc;
  648.     ngx_http_status_t           *status;
  649.     ngx_http_upstream_t         *u;
  650.     ngx_http_uwsgi_loc_conf_t   *uwcf;
  651. #if (NGX_HTTP_CACHE)
  652.     ngx_http_uwsgi_main_conf_t  *uwmcf;
  653. #endif

  655.     if (ngx_http_upstream_create(r) != NGX_OK) {
  656.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  657.     }

  659.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  660.     if (status == NULL) {
  661.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  662.     }

  664.     ngx_http_set_ctx(r, status, ngx_http_uwsgi_module);

  666.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  668.     u = r->upstream;

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

  672. #if (NGX_HTTP_SSL)
  673.         u->ssl = uwcf->ssl;

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

  678.         } else {
  679.             ngx_str_set(&u->schema, "uwsgi://");
  680.         }
  681. #else
  682.         ngx_str_set(&u->schema, "uwsgi://");
  683. #endif

  685.     } else {
  686.         if (ngx_http_uwsgi_eval(r, uwcf) != NGX_OK) {
  687.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  688.         }
  689.     }

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

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

  695. #if (NGX_HTTP_CACHE)
  696.     uwmcf = ngx_http_get_module_main_conf(r, ngx_http_uwsgi_module);

  698.     u->caches = &uwmcf->caches;
  699.     u->create_key = ngx_http_uwsgi_create_key;
  700. #endif

  702.     u->create_request = ngx_http_uwsgi_create_request;
  703.     u->reinit_request = ngx_http_uwsgi_reinit_request;
  704.     u->process_header = ngx_http_uwsgi_process_status_line;
  705.     u->abort_request = ngx_http_uwsgi_abort_request;
  706.     u->finalize_request = ngx_http_uwsgi_finalize_request;
  707.     r->state = 0;

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

  711.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  712.     if (u->pipe == NULL) {
  713.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  714.     }

  716.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  717.     u->pipe->input_ctx = r;

  719.     u->input_filter_init = ngx_http_uwsgi_input_filter_init;
  720.     u->input_filter = ngx_http_upstream_non_buffered_filter;
  721.     u->input_filter_ctx = r;

  723.     if (!uwcf->upstream.request_buffering
  724.         && uwcf->upstream.pass_request_body
  725.         && !r->headers_in.chunked)
  726.     {
  727.         r->request_body_no_buffering = 1;
  728.     }

  730.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  732.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  733.         return rc;
  734.     }

  736.     return NGX_DONE;
  737. }


  740. static ngx_int_t
  741. ‌ngx_http_uwsgi_eval(ngx_http_request_t *r, ngx_http_uwsgi_loc_conf_t * uwcf)
  742. {
  743.     size_t                add;
  744.     ngx_url_t             url;
  745.     ngx_http_upstream_t  *u;

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

  749.     if (ngx_http_script_run(r, &url.url, uwcf->uwsgi_lengths->elts, 0,
  750.                             uwcf->uwsgi_values->elts)
  751.         == NULL)
  752.     {
  753.         return NGX_ERROR;
  754.     }

  756.     if (url.url.len > 8
  757.         && ngx_strncasecmp(url.url.data, (u_char *) "uwsgi://", 8) == 0)
  758.     {
  759.         add = 8;

  761.     } else if (url.url.len > 9
  762.                && ngx_strncasecmp(url.url.data, (u_char *) "suwsgi://", 9) == 0)
  763.     {

  765. #if (NGX_HTTP_SSL)
  766.         add = 9;
  767.         r->upstream->ssl = 1;
  768. #else
  769.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  770.                       "suwsgi protocol requires SSL support");
  771.         return NGX_ERROR;
  772. #endif

  774.     } else {
  775.         add = 0;
  776.     }

  778.     u = r->upstream;

  780.     if (add) {
  781.         u->schema.len = add;
  782.         u->schema.data = url.url.data;

  784.         url.url.data += add;
  785.         url.url.len -= add;

  787.     } else {
  788.         ngx_str_set(&u->schema, "uwsgi://");
  789.     }

  791.     url.no_resolve = 1;

  793.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  794.         if (url.err) {
  795.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  796.                           "%s in upstream \"%V\"", url.err, &url.url);
  797.         }

  799.         return NGX_ERROR;
  800.     }

  802.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  803.     if (u->resolved == NULL) {
  804.         return NGX_ERROR;
  805.     }

  807.     if (url.addrs) {
  808.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  809.         u->resolved->socklen = url.addrs[0].socklen;
  810.         u->resolved->name = url.addrs[0].name;
  811.         u->resolved->naddrs = 1;
  812.     }

  814.     u->resolved->host = url.host;
  815.     u->resolved->port = url.port;
  816.     u->resolved->no_port = url.no_port;

  818.     return NGX_OK;
  819. }


  822. #if (NGX_HTTP_CACHE)

  824. static ngx_int_t
  825. ‌ngx_http_uwsgi_create_key(ngx_http_request_t *r)
  826. {
  827.     ngx_str_t                  *key;
  828.     ngx_http_uwsgi_loc_conf_t  *uwcf;

  830.     key = ngx_array_push(&r->cache->keys);
  831.     if (key == NULL) {
  832.         return NGX_ERROR;
  833.     }

  835.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  837.     if (ngx_http_complex_value(r, &uwcf->cache_key, key) != NGX_OK) {
  838.         return NGX_ERROR;
  839.     }

  841.     return NGX_OK;
  842. }

  844. #endif


  847. static ngx_int_t
  848. ‌ngx_http_uwsgi_create_request(ngx_http_request_t *r)
  849. {
  850.     u_char                        ch, sep, *lowcase_key;
  851.     size_t                        key_len, val_len, len, allocated;
  852.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  853.     ngx_buf_t                    *b;
  854.     ngx_chain_t                  *cl, *body;
  855.     ngx_list_part_t              *part;
  856.     ngx_table_elt_t              *header, *hn, **ignored;
  857.     ngx_http_uwsgi_params_t      *params;
  858.     ngx_http_script_code_pt       code;
  859.     ngx_http_script_engine_t      e, le;
  860.     ngx_http_uwsgi_loc_conf_t    *uwcf;
  861.     ngx_http_script_len_code_pt   lcode;

  863.     len = 0;
  864.     header_params = 0;
  865.     ignored = NULL;

  867.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  869. #if (NGX_HTTP_CACHE)
  870.     params = r->upstream->cacheable ? &uwcf->params_cache : &uwcf->params;
  871. #else
  872.     params = &uwcf->params;
  873. #endif

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

  878.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  879.         le.flushed = 1;

  881.         le.ip = params->lengths->elts;
  882.         le.request = r;

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

  886.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  887.             key_len = lcode(&le);

  889.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  890.             skip_empty = lcode(&le);

  892.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  893.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  894.             }
  895.             le.ip += sizeof(uintptr_t);

  897.             if (skip_empty && val_len == 0) {
  898.                 continue;
  899.             }

  901.             len += 2 + key_len + 2 + val_len;
  902.         }
  903.     }

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

  907.         allocated = 0;
  908.         lowcase_key = NULL;

  910.         if (ngx_http_link_multi_headers(r) != NGX_OK) {
  911.             return NGX_ERROR;
  912.         }

  914.         if (params->number || r->headers_in.multi) {
  915.             n = 0;
  916.             part = &r->headers_in.headers.part;

  918.             while (part) {
  919.                 n += part->nelts;
  920.                 part = part->next;
  921.             }

  923.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  924.             if (ignored == NULL) {
  925.                 return NGX_ERROR;
  926.             }
  927.         }

  929.         part = &r->headers_in.headers.part;
  930.         header = part->elts;

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

  934.             if (i >= part->nelts) {
  935.                 if (part->next == NULL) {
  936.                     break;
  937.                 }

  939.                 part = part->next;
  940.                 header = part->elts;
  941.                 i = 0;
  942.             }

  944.             for (n = 0; n < header_params; n++) {
  945.                 if (&header[i] == ignored[n]) {
  946.                     goto next_length;
  947.                 }
  948.             }

  950.             if (params->number) {
  951.                 if (allocated < header[i].key.len) {
  952.                     allocated = header[i].key.len + 16;
  953.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  954.                     if (lowcase_key == NULL) {
  955.                         return NGX_ERROR;
  956.                     }
  957.                 }

  959.                 hash = 0;

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

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

  967.                     } else if (ch == '-') {
  968.                         ch = '_';
  969.                     }

  971.                     hash = ngx_hash(hash, ch);
  972.                     lowcase_key[n] = ch;
  973.                 }

  975.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  976.                     ignored[header_params++] = &header[i];
  977.                     continue;
  978.                 }
  979.             }

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

  984.             for (hn = header[i].next; hn; hn = hn->next) {
  985.                 len += hn->value.len + 2;
  986.                 ignored[header_params++] = hn;
  987.             }

  989.         next_length:

  991.             continue;
  992.         }
  993.     }

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

  997. #if 0
  998.     /* allow custom uwsgi packet */
  999.     if (len > 0 && len < 2) {
  1000.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1001.                       "uwsgi request is too little: %uz", len);
  1002.         return NGX_ERROR;
  1003.     }
  1004. #endif

  1006.     if (len > 65535) {
  1007.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  1008.                       "uwsgi request is too big: %uz", len);
  1009.         return NGX_ERROR;
  1010.     }

  1012.     b = ngx_create_temp_buf(r->pool, len + 4);
  1013.     if (b == NULL) {
  1014.         return NGX_ERROR;
  1015.     }

  1017.     cl = ngx_alloc_chain_link(r->pool);
  1018.     if (cl == NULL) {
  1019.         return NGX_ERROR;
  1020.     }

  1022.     cl->buf = b;

  1024.     *b->last++ = (u_char) uwcf->modifier1;
  1025.     *b->last++ = (u_char) (len & 0xff);
  1026.     *b->last++ = (u_char) ((len >> 8) & 0xff);
  1027.     *b->last++ = (u_char) uwcf->modifier2;

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

  1032.         e.ip = params->values->elts;
  1033.         e.pos = b->last;
  1034.         e.request = r;
  1035.         e.flushed = 1;

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

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

  1041.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1042.             key_len = (u_char) lcode(&le);

  1044.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1045.             skip_empty = lcode(&le);

  1047.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  1048.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1049.             }
  1050.             le.ip += sizeof(uintptr_t);

  1052.             if (skip_empty && val_len == 0) {
  1053.                 e.skip = 1;

  1055.                 while (*(uintptr_t *) e.ip) {
  1056.                     code = *(ngx_http_script_code_pt *) e.ip;
  1057.                     code((ngx_http_script_engine_t *) &e);
  1058.                 }
  1059.                 e.ip += sizeof(uintptr_t);

  1061.                 e.skip = 0;

  1063.                 continue;
  1064.             }

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

  1069.             code = *(ngx_http_script_code_pt *) e.ip;
  1070.             code((ngx_http_script_engine_t *) &e);

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

  1075.             while (*(uintptr_t *) e.ip) {
  1076.                 code = *(ngx_http_script_code_pt *) e.ip;
  1077.                 code((ngx_http_script_engine_t *) &e);
  1078.             }

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

  1082.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1083.                            "uwsgi param: \"%*s: %*s\"",
  1084.                            key_len, e.pos - (key_len + 2 + val_len),
  1085.                            val_len, e.pos - val_len);
  1086.         }

  1088.         b->last = e.pos;
  1089.     }

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

  1093.         part = &r->headers_in.headers.part;
  1094.         header = part->elts;

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

  1098.             if (i >= part->nelts) {
  1099.                 if (part->next == NULL) {
  1100.                     break;
  1101.                 }

  1103.                 part = part->next;
  1104.                 header = part->elts;
  1105.                 i = 0;
  1106.             }

  1108.             for (n = 0; n < header_params; n++) {
  1109.                 if (&header[i] == ignored[n]) {
  1110.                     goto next_value;
  1111.                 }
  1112.             }

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

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

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

  1125.                 } else if (ch == '-') {
  1126.                     ch = '_';
  1127.                 }

  1129.                 *b->last++ = ch;
  1130.             }

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

  1134.             for (hn = header[i].next; hn; hn = hn->next) {
  1135.                 val_len += hn->value.len + 2;
  1136.             }

  1138.             *b->last++ = (u_char) (val_len & 0xff);
  1139.             *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1140.             b->last = ngx_copy(b->last, header[i].value.data,
  1141.                                header[i].value.len);

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

  1145.                 if (header[i].key.len == sizeof("Cookie") - 1
  1146.                     && ngx_strncasecmp(header[i].key.data, (u_char *) "Cookie",
  1147.                                        sizeof("Cookie") - 1)
  1148.                        == 0)
  1149.                 {
  1150.                     sep = ';';

  1152.                 } else {
  1153.                     sep = ',';
  1154.                 }

  1156.                 for (hn = header[i].next; hn; hn = hn->next) {
  1157.                     *b->last++ = sep;
  1158.                     *b->last++ = ' ';
  1159.                     b->last = ngx_copy(b->last, hn->value.data, hn->value.len);
  1160.                 }
  1161.             }

  1163.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1164.                            "uwsgi param: \"%*s: %*s\"",
  1165.                            key_len, b->last - (key_len + 2 + val_len),
  1166.                            val_len, b->last - val_len);
  1167.         next_value:

  1169.             continue;
  1170.         }
  1171.     }

  1173.     b->last = ngx_copy(b->last, uwcf->uwsgi_string.data,
  1174.                        uwcf->uwsgi_string.len);

  1176.     if (r->request_body_no_buffering) {
  1177.         r->upstream->request_bufs = cl;

  1179.     } else if (uwcf->upstream.pass_request_body) {
  1180.         body = r->upstream->request_bufs;
  1181.         r->upstream->request_bufs = cl;

  1183.         while (body) {
  1184.             b = ngx_alloc_buf(r->pool);
  1185.             if (b == NULL) {
  1186.                 return NGX_ERROR;
  1187.             }

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

  1191.             cl->next = ngx_alloc_chain_link(r->pool);
  1192.             if (cl->next == NULL) {
  1193.                 return NGX_ERROR;
  1194.             }

  1196.             cl = cl->next;
  1197.             cl->buf = b;

  1199.             body = body->next;
  1200.         }

  1202.     } else {
  1203.         r->upstream->request_bufs = cl;
  1204.     }

  1206.     b->flush = 1;
  1207.     cl->next = NULL;

  1209.     return NGX_OK;
  1210. }


  1213. static ngx_int_t
  1214. ‌ngx_http_uwsgi_reinit_request(ngx_http_request_t *r)
  1215. {
  1216.     ngx_http_status_t  *status;

  1218.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1220.     if (status == NULL) {
  1221.         return NGX_OK;
  1222.     }

  1224.     status->code = 0;
  1225.     status->count = 0;
  1226.     status->start = NULL;
  1227.     status->end = NULL;

  1229.     r->upstream->process_header = ngx_http_uwsgi_process_status_line;
  1230.     r->state = 0;

  1232.     return NGX_OK;
  1233. }


  1236. static ngx_int_t
  1237. ‌ngx_http_uwsgi_process_status_line(ngx_http_request_t *r)
  1238. {
  1239.     size_t                 len;
  1240.     ngx_int_t              rc;
  1241.     ngx_http_status_t     *status;
  1242.     ngx_http_upstream_t   *u;

  1244.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1246.     if (status == NULL) {
  1247.         return NGX_ERROR;
  1248.     }

  1250.     u = r->upstream;

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

  1254.     if (rc == NGX_AGAIN) {
  1255.         return rc;
  1256.     }

  1258.     if (rc == NGX_ERROR) {
  1259.         u->process_header = ngx_http_uwsgi_process_header;
  1260.         return ngx_http_uwsgi_process_header(r);
  1261.     }

  1263.     if (u->state && u->state->status == 0) {
  1264.         u->state->status = status->code;
  1265.     }

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

  1269.     len = status->end - status->start;
  1270.     u->headers_in.status_line.len = len;

  1272.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1273.     if (u->headers_in.status_line.data == NULL) {
  1274.         return NGX_ERROR;
  1275.     }

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

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

  1283.     u->process_header = ngx_http_uwsgi_process_header;

  1285.     return ngx_http_uwsgi_process_header(r);
  1286. }


  1289. static ngx_int_t
  1290. ‌ngx_http_uwsgi_process_header(ngx_http_request_t *r)
  1291. {
  1292.     ngx_str_t                      *status_line;
  1293.     ngx_int_t                       rc, status;
  1294.     ngx_table_elt_t                *h;
  1295.     ngx_http_upstream_t            *u;
  1296.     ngx_http_upstream_header_t     *hh;
  1297.     ngx_http_upstream_main_conf_t  *umcf;

  1299.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1301.     for ( ;; ) {

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

  1305.         if (rc == NGX_OK) {

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

  1309.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1310.             if (h == NULL) {
  1311.                 return NGX_ERROR;
  1312.             }

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

  1316.             h->key.len = r->header_name_end - r->header_name_start;
  1317.             h->value.len = r->header_end - r->header_start;

  1319.             h->key.data = ngx_pnalloc(r->pool,
  1320.                                       h->key.len + 1 + h->value.len + 1
  1321.                                       + h->key.len);
  1322.             if (h->key.data == NULL) {
  1323.                 h->hash = 0;
  1324.                 return NGX_ERROR;
  1325.             }

  1327.             h->value.data = h->key.data + h->key.len + 1;
  1328.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1330.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1331.             h->key.data[h->key.len] = '\0';
  1332.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1333.             h->value.data[h->value.len] = '\0';

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

  1338.             } else {
  1339.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1340.             }

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

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

  1348.                 if (rc != NGX_OK) {
  1349.                     return rc;
  1350.                 }
  1351.             }

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

  1356.             continue;
  1357.         }

  1359.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1366.             u = r->upstream;

  1368.             if (u->headers_in.status_n) {
  1369.                 goto done;
  1370.             }

  1372.             if (u->headers_in.status) {
  1373.                 status_line = &u->headers_in.status->value;

  1375.                 status = ngx_atoi(status_line->data, 3);
  1376.                 if (status == NGX_ERROR) {
  1377.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1378.                                   "upstream sent invalid status \"%V\"",
  1379.                                   status_line);
  1380.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1381.                 }

  1383.                 u->headers_in.status_n = status;

  1385.                 if (status_line->len > 3) {
  1386.                     u->headers_in.status_line = *status_line;
  1387.                 }

  1389.             } else if (u->headers_in.location) {
  1390.                 u->headers_in.status_n = 302;
  1391.                 ngx_str_set(&u->headers_in.status_line,
  1392.                             "302 Moved Temporarily");

  1394.             } else {
  1395.                 u->headers_in.status_n = 200;
  1396.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1397.             }

  1399.             if (u->state && u->state->status == 0) {
  1400.                 u->state->status = u->headers_in.status_n;
  1401.             }

  1403.         done:

  1405.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1406.                 && r->headers_in.upgrade)
  1407.             {
  1408.                 u->upgrade = 1;
  1409.             }

  1411.             return NGX_OK;
  1412.         }

  1414.         if (rc == NGX_AGAIN) {
  1415.             return NGX_AGAIN;
  1416.         }

  1418.         /* rc == NGX_HTTP_PARSE_INVALID_HEADER */

  1420.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1421.                       "upstream sent invalid header: \"%*s\\x%02xd...\"",
  1422.                       r->header_end - r->header_name_start,
  1423.                       r->header_name_start, *r->header_end);

  1425.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1426.     }
  1427. }


  1430. static ngx_int_t
  1431. ‌ngx_http_uwsgi_input_filter_init(void *data)
  1432. {
  1433.     ngx_http_request_t   *r = data;
  1434.     ngx_http_upstream_t  *u;

  1436.     u = r->upstream;

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

  1442.     if (u->headers_in.status_n == NGX_HTTP_NO_CONTENT
  1443.         || u->headers_in.status_n == NGX_HTTP_NOT_MODIFIED)
  1444.     {
  1445.         u->pipe->length = 0;
  1446.         u->length = 0;

  1448.     } else if (r->method == NGX_HTTP_HEAD) {
  1449.         u->pipe->length = -1;
  1450.         u->length = -1;

  1452.     } else {
  1453.         u->pipe->length = u->headers_in.content_length_n;
  1454.         u->length = u->headers_in.content_length_n;
  1455.     }

  1457.     return NGX_OK;
  1458. }


  1461. static void
  1462. ‌ngx_http_uwsgi_abort_request(ngx_http_request_t *r)
  1463. {
  1464.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1465.                    "abort http uwsgi request");

  1467.     return;
  1468. }


  1471. static void
  1472. ‌ngx_http_uwsgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1473. {
  1474.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1475.                    "finalize http uwsgi request");

  1477.     return;
  1478. }


  1481. static void *
  1482. ‌ngx_http_uwsgi_create_main_conf(ngx_conf_t *cf)
  1483. {
  1484.     ngx_http_uwsgi_main_conf_t  *conf;

  1486.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_main_conf_t));
  1487.     if (conf == NULL) {
  1488.         return NULL;
  1489.     }

  1491. #if (NGX_HTTP_CACHE)
  1492.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1493.                        sizeof(ngx_http_file_cache_t *))
  1494.         != NGX_OK)
  1495.     {
  1496.         return NULL;
  1497.     }
  1498. #endif

  1500.     return conf;
  1501. }


  1504. static void *
  1505. ‌ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf)
  1506. {
  1507.     ngx_http_uwsgi_loc_conf_t  *conf;

  1509.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_loc_conf_t));
  1510.     if (conf == NULL) {
  1511.         return NULL;
  1512.     }

  1514.     /*
  1515.      * set by ngx_pcalloc():
  1516.      *
  1517.      *     conf->upstream.bufs.num = 0;
  1518.      *     conf->upstream.ignore_headers = 0;
  1519.      *     conf->upstream.next_upstream = 0;
  1520.      *     conf->upstream.cache_zone = NULL;
  1521.      *     conf->upstream.cache_use_stale = 0;
  1522.      *     conf->upstream.cache_methods = 0;
  1523.      *     conf->upstream.temp_path = NULL;
  1524.      *     conf->upstream.hide_headers_hash = { NULL, 0 };
  1525.      *     conf->upstream.store_lengths = NULL;
  1526.      *     conf->upstream.store_values = NULL;
  1527.      *
  1528.      *     conf->uwsgi_string = { 0, NULL };
  1529.      *     conf->ssl = 0;
  1530.      *     conf->ssl_protocols = 0;
  1531.      *     conf->ssl_ciphers = { 0, NULL };
  1532.      *     conf->ssl_trusted_certificate = { 0, NULL };
  1533.      *     conf->ssl_crl = { 0, NULL };
  1534.      */

  1536.     conf->modifier1 = NGX_CONF_UNSET_UINT;
  1537.     conf->modifier2 = NGX_CONF_UNSET_UINT;

  1539.     conf->upstream.store = NGX_CONF_UNSET;
  1540.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1541.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1542.     conf->upstream.buffering = NGX_CONF_UNSET;
  1543.     conf->upstream.request_buffering = NGX_CONF_UNSET;
  1544.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1545.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1547.     conf->upstream.local = NGX_CONF_UNSET_PTR;
  1548.     conf->upstream.socket_keepalive = NGX_CONF_UNSET;

  1550.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1551.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1552.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1553.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1555.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1556.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1557.     conf->upstream.limit_rate = NGX_CONF_UNSET_PTR;

  1559.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1560.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1561.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1563.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1564.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1566. #if (NGX_HTTP_CACHE)
  1567.     conf->upstream.cache = NGX_CONF_UNSET;
  1568.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1569.     conf->upstream.cache_max_range_offset = NGX_CONF_UNSET;
  1570.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1571.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1572.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1573.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1574.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1575.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1576.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1577.     conf->upstream.cache_background_update = NGX_CONF_UNSET;
  1578. #endif

  1580.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1581.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1583.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1585. #if (NGX_HTTP_SSL)
  1586.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  1587.     conf->upstream.ssl_name = NGX_CONF_UNSET_PTR;
  1588.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  1589.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  1590.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  1591.     conf->upstream.ssl_certificate = NGX_CONF_UNSET_PTR;
  1592.     conf->upstream.ssl_certificate_key = NGX_CONF_UNSET_PTR;
  1593.     conf->upstream.ssl_passwords = NGX_CONF_UNSET_PTR;
  1594.     conf->ssl_conf_commands = NGX_CONF_UNSET_PTR;
  1595. #endif

  1597.     /* "uwsgi_cyclic_temp_file" is disabled */
  1598.     conf->upstream.cyclic_temp_file = 0;

  1600.     conf->upstream.change_buffering = 1;

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

  1604.     return conf;
  1605. }


  1608. static char *
  1609. ‌ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1610. {
  1611.     ngx_http_uwsgi_loc_conf_t *prev = parent;
  1612.     ngx_http_uwsgi_loc_conf_t *conf = child;

  1614.     size_t                        size;
  1615.     ngx_int_t                     rc;
  1616.     ngx_hash_init_t               hash;
  1617.     ngx_http_core_loc_conf_t     *clcf;

  1619. #if (NGX_HTTP_CACHE)

  1621.     if (conf->upstream.store > 0) {
  1622.         conf->upstream.cache = 0;
  1623.     }

  1625.     if (conf->upstream.cache > 0) {
  1626.         conf->upstream.store = 0;
  1627.     }

  1629. #endif

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

  1634.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1635.         conf->upstream.store_values = prev->upstream.store_values;
  1636.     }

  1638.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1639.                               prev->upstream.store_access, 0600);

  1641.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1642.                               prev->upstream.next_upstream_tries, 0);

  1644.     ngx_conf_merge_value(conf->upstream.buffering,
  1645.                               prev->upstream.buffering, 1);

  1647.     ngx_conf_merge_value(conf->upstream.request_buffering,
  1648.                               prev->upstream.request_buffering, 1);

  1650.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1651.                               prev->upstream.ignore_client_abort, 0);

  1653.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1654.                               prev->upstream.force_ranges, 0);

  1656.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1657.                               prev->upstream.local, NULL);

  1659.     ngx_conf_merge_value(conf->upstream.socket_keepalive,
  1660.                               prev->upstream.socket_keepalive, 0);

  1662.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1663.                               prev->upstream.connect_timeout, 60000);

  1665.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1666.                               prev->upstream.send_timeout, 60000);

  1668.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1669.                               prev->upstream.read_timeout, 60000);

  1671.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1672.                               prev->upstream.next_upstream_timeout, 0);

  1674.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1675.                               prev->upstream.send_lowat, 0);

  1677.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1678.                               prev->upstream.buffer_size,
  1679.                               (size_t) ngx_pagesize);

  1681.     ngx_conf_merge_ptr_value(conf->upstream.limit_rate,
  1682.                               prev->upstream.limit_rate, NULL);


  1685.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1686.                               8, ngx_pagesize);

  1688.     if (conf->upstream.bufs.num < 2) {
  1689.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1690.                            "there must be at least 2 \"uwsgi_buffers\"");
  1691.         return NGX_CONF_ERROR;
  1692.     }


  1695.     size = conf->upstream.buffer_size;
  1696.     if (size < conf->upstream.bufs.size) {
  1697.         size = conf->upstream.bufs.size;
  1698.     }


  1701.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1702.                               prev->upstream.busy_buffers_size_conf,
  1703.                               NGX_CONF_UNSET_SIZE);

  1705.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1706.         conf->upstream.busy_buffers_size = 2 * size;
  1707.     } else {
  1708.         conf->upstream.busy_buffers_size =
  1709.             conf->upstream.busy_buffers_size_conf;
  1710.     }

  1712.     if (conf->upstream.busy_buffers_size < size) {
  1713.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1714.             "\"uwsgi_busy_buffers_size\" must be equal to or greater "
  1715.             "than the maximum of the value of \"uwsgi_buffer_size\" and "
  1716.             "one of the \"uwsgi_buffers\"");

  1718.         return NGX_CONF_ERROR;
  1719.     }

  1721.     if (conf->upstream.busy_buffers_size
  1722.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1723.     {
  1724.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1725.             "\"uwsgi_busy_buffers_size\" must be less than "
  1726.             "the size of all \"uwsgi_buffers\" minus one buffer");

  1728.         return NGX_CONF_ERROR;
  1729.     }


  1732.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1733.                               prev->upstream.temp_file_write_size_conf,
  1734.                               NGX_CONF_UNSET_SIZE);

  1736.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1737.         conf->upstream.temp_file_write_size = 2 * size;
  1738.     } else {
  1739.         conf->upstream.temp_file_write_size =
  1740.             conf->upstream.temp_file_write_size_conf;
  1741.     }

  1743.     if (conf->upstream.temp_file_write_size < size) {
  1744.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1745.             "\"uwsgi_temp_file_write_size\" must be equal to or greater than "
  1746.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1747.             "one of the \"uwsgi_buffers\"");

  1749.         return NGX_CONF_ERROR;
  1750.     }


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

  1757.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1758.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1759.     } else {
  1760.         conf->upstream.max_temp_file_size =
  1761.             conf->upstream.max_temp_file_size_conf;
  1762.     }

  1764.     if (conf->upstream.max_temp_file_size != 0
  1765.         && conf->upstream.max_temp_file_size < size)
  1766.     {
  1767.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1768.             "\"uwsgi_max_temp_file_size\" must be equal to zero to disable "
  1769.             "temporary files usage or must be equal to or greater than "
  1770.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1771.             "one of the \"uwsgi_buffers\"");

  1773.         return NGX_CONF_ERROR;
  1774.     }


  1777.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1778.                                  prev->upstream.ignore_headers,
  1779.                                  NGX_CONF_BITMASK_SET);


  1782.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1783.                                  prev->upstream.next_upstream,
  1784.                                  (NGX_CONF_BITMASK_SET
  1785.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1786.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1788.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1789.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1790.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1791.     }

  1793.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1794.                                   prev->upstream.temp_path,
  1795.                                   &ngx_http_uwsgi_temp_path)
  1796.         != NGX_OK)
  1797.     {
  1798.         return NGX_CONF_ERROR;
  1799.     }

  1801. #if (NGX_HTTP_CACHE)

  1803.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1804.         ngx_conf_merge_value(conf->upstream.cache,
  1805.                               prev->upstream.cache, 0);

  1807.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1808.         conf->upstream.cache_value = prev->upstream.cache_value;
  1809.     }

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

  1814.         shm_zone = conf->upstream.cache_zone;

  1816.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1817.                            "\"uwsgi_cache\" zone \"%V\" is unknown",
  1818.                            &shm_zone->shm.name);

  1820.         return NGX_CONF_ERROR;
  1821.     }

  1823.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1824.                               prev->upstream.cache_min_uses, 1);

  1826.     ngx_conf_merge_off_value(conf->upstream.cache_max_range_offset,
  1827.                               prev->upstream.cache_max_range_offset,
  1828.                               NGX_MAX_OFF_T_VALUE);

  1830.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1831.                               prev->upstream.cache_use_stale,
  1832.                               (NGX_CONF_BITMASK_SET
  1833.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1835.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1836.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1837.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1838.     }

  1840.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1841.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1842.     }

  1844.     if (conf->upstream.cache_methods == 0) {
  1845.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1846.     }

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

  1850.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1851.                              prev->upstream.cache_bypass, NULL);

  1853.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1854.                              prev->upstream.no_cache, NULL);

  1856.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1857.                              prev->upstream.cache_valid, NULL);

  1859.     if (conf->cache_key.value.data == NULL) {
  1860.         conf->cache_key = prev->cache_key;
  1861.     }

  1863.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1864.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1865.                            "no \"uwsgi_cache_key\" for \"uwsgi_cache\"");
  1866.     }

  1868.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1869.                               prev->upstream.cache_lock, 0);

  1871.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1872.                               prev->upstream.cache_lock_timeout, 5000);

  1874.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1875.                               prev->upstream.cache_lock_age, 5000);

  1877.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1878.                               prev->upstream.cache_revalidate, 0);

  1880.     ngx_conf_merge_value(conf->upstream.cache_background_update,
  1881.                               prev->upstream.cache_background_update, 0);

  1883. #endif

  1885.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1886.                          prev->upstream.pass_request_headers, 1);
  1887.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1888.                          prev->upstream.pass_request_body, 1);

  1890.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1891.                          prev->upstream.intercept_errors, 0);

  1893. #if (NGX_HTTP_SSL)

  1895.     if (ngx_http_uwsgi_merge_ssl(cf, conf, prev) != NGX_OK) {
  1896.         return NGX_CONF_ERROR;
  1897.     }

  1899.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  1900.                               prev->upstream.ssl_session_reuse, 1);

  1902.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  1903.                               (NGX_CONF_BITMASK_SET|NGX_SSL_DEFAULT_PROTOCOLS));

  1905.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  1906.                              "DEFAULT");

  1908.     ngx_conf_merge_ptr_value(conf->upstream.ssl_name,
  1909.                               prev->upstream.ssl_name, NULL);
  1910.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  1911.                               prev->upstream.ssl_server_name, 0);
  1912.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  1913.                               prev->upstream.ssl_verify, 0);
  1914.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  1915.                               prev->ssl_verify_depth, 1);
  1916.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  1917.                               prev->ssl_trusted_certificate, "");
  1918.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  1920.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate,
  1921.                               prev->upstream.ssl_certificate, NULL);
  1922.     ngx_conf_merge_ptr_value(conf->upstream.ssl_certificate_key,
  1923.                               prev->upstream.ssl_certificate_key, NULL);
  1924.     ngx_conf_merge_ptr_value(conf->upstream.ssl_passwords,
  1925.                               prev->upstream.ssl_passwords, NULL);

  1927.     ngx_conf_merge_ptr_value(conf->ssl_conf_commands,
  1928.                               prev->ssl_conf_commands, NULL);

  1930.     if (conf->ssl && ngx_http_uwsgi_set_ssl(cf, conf) != NGX_OK) {
  1931.         return NGX_CONF_ERROR;
  1932.     }

  1934. #endif

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

  1938.     hash.max_size = 512;
  1939.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1940.     hash.name = "uwsgi_hide_headers_hash";

  1942.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1943.             &prev->upstream, ngx_http_uwsgi_hide_headers, &hash)
  1944.         != NGX_OK)
  1945.     {
  1946.         return NGX_CONF_ERROR;
  1947.     }

  1949.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1951.     if (clcf->noname
  1952.         && conf->upstream.upstream == NULL && conf->uwsgi_lengths == NULL)
  1953.     {
  1954.         conf->upstream.upstream = prev->upstream.upstream;

  1956.         conf->uwsgi_lengths = prev->uwsgi_lengths;
  1957.         conf->uwsgi_values = prev->uwsgi_values;

  1959. #if (NGX_HTTP_SSL)
  1960.         conf->ssl = prev->ssl;
  1961. #endif
  1962.     }

  1964.     if (clcf->lmt_excpt && clcf->handler == NULL
  1965.         && (conf->upstream.upstream || conf->uwsgi_lengths))
  1966.     {
  1967.         clcf->handler = ngx_http_uwsgi_handler;
  1968.     }

  1970.     ngx_conf_merge_uint_value(conf->modifier1, prev->modifier1, 0);
  1971.     ngx_conf_merge_uint_value(conf->modifier2, prev->modifier2, 0);

  1973.     if (conf->params_source == NULL) {
  1974.         conf->params = prev->params;
  1975. #if (NGX_HTTP_CACHE)
  1976.         conf->params_cache = prev->params_cache;
  1977. #endif
  1978.         conf->params_source = prev->params_source;
  1979.     }

  1981.     rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params, NULL);
  1982.     if (rc != NGX_OK) {
  1983.         return NGX_CONF_ERROR;
  1984.     }

  1986. #if (NGX_HTTP_CACHE)

  1988.     if (conf->upstream.cache) {
  1989.         rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params_cache,
  1990.                                         ngx_http_uwsgi_cache_headers);
  1991.         if (rc != NGX_OK) {
  1992.             return NGX_CONF_ERROR;
  1993.         }
  1994.     }

  1996. #endif

  1998.     /*
  1999.      * special handling to preserve conf->params in the "http" section
  2000.      * to inherit it to all servers
  2001.      */

  2003.     if (prev->params.hash.buckets == NULL
  2004.         && conf->params_source == prev->params_source)
  2005.     {
  2006.         prev->params = conf->params;
  2007. #if (NGX_HTTP_CACHE)
  2008.         prev->params_cache = conf->params_cache;
  2009. #endif
  2010.     }

  2012.     return NGX_CONF_OK;
  2013. }


  2016. static ngx_int_t
  2017. ‌ngx_http_uwsgi_init_params(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  2018.     ngx_http_uwsgi_params_t *params, ngx_keyval_t *default_params)
  2019. {
  2020.     u_char                       *p;
  2021.     size_t                        size;
  2022.     uintptr_t                    *code;
  2023.     ngx_uint_t                    i, nsrc;
  2024.     ngx_array_t                   headers_names, params_merged;
  2025.     ngx_keyval_t                 *h;
  2026.     ngx_hash_key_t               *hk;
  2027.     ngx_hash_init_t               hash;
  2028.     ngx_http_upstream_param_t    *src, *s;
  2029.     ngx_http_script_compile_t     sc;
  2030.     ngx_http_script_copy_code_t  *copy;

  2032.     if (params->hash.buckets) {
  2033.         return NGX_OK;
  2034.     }

  2036.     if (conf->params_source == NULL && default_params == NULL) {
  2037.         params->hash.buckets = (void *) 1;
  2038.         return NGX_OK;
  2039.     }

  2041.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  2042.     if (params->lengths == NULL) {
  2043.         return NGX_ERROR;
  2044.     }

  2046.     params->values = ngx_array_create(cf->pool, 512, 1);
  2047.     if (params->values == NULL) {
  2048.         return NGX_ERROR;
  2049.     }

  2051.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  2052.         != NGX_OK)
  2053.     {
  2054.         return NGX_ERROR;
  2055.     }

  2057.     if (conf->params_source) {
  2058.         src = conf->params_source->elts;
  2059.         nsrc = conf->params_source->nelts;

  2061.     } else {
  2062.         src = NULL;
  2063.         nsrc = 0;
  2064.     }

  2066.     if (default_params) {
  2067.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  2068.                            sizeof(ngx_http_upstream_param_t))
  2069.             != NGX_OK)
  2070.         {
  2071.             return NGX_ERROR;
  2072.         }

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

  2076.             s = ngx_array_push(&params_merged);
  2077.             if (s == NULL) {
  2078.                 return NGX_ERROR;
  2079.             }

  2081.             *s = src[i];
  2082.         }

  2084.         h = default_params;

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

  2088.             src = params_merged.elts;
  2089.             nsrc = params_merged.nelts;

  2091.             for (i = 0; i < nsrc; i++) {
  2092.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  2093.                     goto next;
  2094.                 }
  2095.             }

  2097.             s = ngx_array_push(&params_merged);
  2098.             if (s == NULL) {
  2099.                 return NGX_ERROR;
  2100.             }

  2102.             s->key = h->key;
  2103.             s->value = h->value;
  2104.             s->skip_empty = 1;

  2106.         next:

  2108.             h++;
  2109.         }

  2111.         src = params_merged.elts;
  2112.         nsrc = params_merged.nelts;
  2113.     }

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

  2117.         if (src[i].key.len > sizeof("HTTP_") - 1
  2118.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  2119.         {
  2120.             hk = ngx_array_push(&headers_names);
  2121.             if (hk == NULL) {
  2122.                 return NGX_ERROR;
  2123.             }

  2125.             hk->key.len = src[i].key.len - 5;
  2126.             hk->key.data = src[i].key.data + 5;
  2127.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  2128.             hk->value = (void *) 1;

  2130.             if (src[i].value.len == 0) {
  2131.                 continue;
  2132.             }
  2133.         }

  2135.         copy = ngx_array_push_n(params->lengths,
  2136.                                 sizeof(ngx_http_script_copy_code_t));
  2137.         if (copy == NULL) {
  2138.             return NGX_ERROR;
  2139.         }

  2141.         copy->code = (ngx_http_script_code_pt) (void *)
  2142.                                                  ngx_http_script_copy_len_code;
  2143.         copy->len = src[i].key.len;

  2145.         copy = ngx_array_push_n(params->lengths,
  2146.                                 sizeof(ngx_http_script_copy_code_t));
  2147.         if (copy == NULL) {
  2148.             return NGX_ERROR;
  2149.         }

  2151.         copy->code = (ngx_http_script_code_pt) (void *)
  2152.                                                  ngx_http_script_copy_len_code;
  2153.         copy->len = src[i].skip_empty;


  2156.         size = (sizeof(ngx_http_script_copy_code_t)
  2157.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  2158.                & ~(sizeof(uintptr_t) - 1);

  2160.         copy = ngx_array_push_n(params->values, size);
  2161.         if (copy == NULL) {
  2162.             return NGX_ERROR;
  2163.         }

  2165.         copy->code = ngx_http_script_copy_code;
  2166.         copy->len = src[i].key.len;

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


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

  2174.         sc.cf = cf;
  2175.         sc.source = &src[i].value;
  2176.         sc.flushes = &params->flushes;
  2177.         sc.lengths = &params->lengths;
  2178.         sc.values = &params->values;

  2180.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2181.             return NGX_ERROR;
  2182.         }

  2184.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  2185.         if (code == NULL) {
  2186.             return NGX_ERROR;
  2187.         }

  2189.         *code = (uintptr_t) NULL;


  2192.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  2193.         if (code == NULL) {
  2194.             return NGX_ERROR;
  2195.         }

  2197.         *code = (uintptr_t) NULL;
  2198.     }

  2200.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  2201.     if (code == NULL) {
  2202.         return NGX_ERROR;
  2203.     }

  2205.     *code = (uintptr_t) NULL;

  2207.     params->number = headers_names.nelts;

  2209.     hash.hash = &params->hash;
  2210.     hash.key = ngx_hash_key_lc;
  2211.     hash.max_size = 512;
  2212.     hash.bucket_size = 64;
  2213.     hash.name = "uwsgi_params_hash";
  2214.     hash.pool = cf->pool;
  2215.     hash.temp_pool = NULL;

  2217.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  2218. }


  2221. static char *
  2222. ‌ngx_http_uwsgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2223. {
  2224.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2226.     size_t                      add;
  2227.     ngx_url_t                   u;
  2228.     ngx_str_t                  *value, *url;
  2229.     ngx_uint_t                  n;
  2230.     ngx_http_core_loc_conf_t   *clcf;
  2231.     ngx_http_script_compile_t   sc;

  2233.     if (uwcf->upstream.upstream || uwcf->uwsgi_lengths) {
  2234.         return "is duplicate";
  2235.     }

  2237.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  2238.     clcf->handler = ngx_http_uwsgi_handler;

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

  2242.     url = &value[1];

  2244.     n = ngx_http_script_variables_count(url);

  2246.     if (n) {

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

  2250.         sc.cf = cf;
  2251.         sc.source = url;
  2252.         sc.lengths = &uwcf->uwsgi_lengths;
  2253.         sc.values = &uwcf->uwsgi_values;
  2254.         sc.variables = n;
  2255.         sc.complete_lengths = 1;
  2256.         sc.complete_values = 1;

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

  2262. #if (NGX_HTTP_SSL)
  2263.         uwcf->ssl = 1;
  2264. #endif

  2266.         return NGX_CONF_OK;
  2267.     }

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

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

  2274. #if (NGX_HTTP_SSL)
  2275.         add = 9;
  2276.         uwcf->ssl = 1;
  2277. #else
  2278.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2279.                            "suwsgi protocol requires SSL support");
  2280.         return NGX_CONF_ERROR;
  2281. #endif

  2283.     } else {
  2284.         add = 0;
  2285.     }

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

  2289.     u.url.len = url->len - add;
  2290.     u.url.data = url->data + add;
  2291.     u.no_resolve = 1;

  2293.     uwcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  2294.     if (uwcf->upstream.upstream == NULL) {
  2295.         return NGX_CONF_ERROR;
  2296.     }

  2298.     if (clcf->name.len && clcf->name.data[clcf->name.len - 1] == '/') {
  2299.         clcf->auto_redirect = 1;
  2300.     }

  2302.     return NGX_CONF_OK;
  2303. }


  2306. static char *
  2307. ‌ngx_http_uwsgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2308. {
  2309.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2311.     ngx_str_t                  *value;
  2312.     ngx_http_script_compile_t   sc;

  2314.     if (uwcf->upstream.store != NGX_CONF_UNSET) {
  2315.         return "is duplicate";
  2316.     }

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

  2320.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2321.         uwcf->upstream.store = 0;
  2322.         return NGX_CONF_OK;
  2323.     }

  2325.     if (value[1].len == 0) {
  2326.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty path");
  2327.         return NGX_CONF_ERROR;
  2328.     }

  2330. #if (NGX_HTTP_CACHE)

  2332.     if (uwcf->upstream.cache > 0) {
  2333.         return "is incompatible with \"uwsgi_cache\"";
  2334.     }

  2336. #endif

  2338.     uwcf->upstream.store = 1;

  2340.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2341.         return NGX_CONF_OK;
  2342.     }

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

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

  2349.     sc.cf = cf;
  2350.     sc.source = &value[1];
  2351.     sc.lengths = &uwcf->upstream.store_lengths;
  2352.     sc.values = &uwcf->upstream.store_values;
  2353.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2354.     sc.complete_lengths = 1;
  2355.     sc.complete_values = 1;

  2357.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2358.         return NGX_CONF_ERROR;
  2359.     }

  2361.     return NGX_CONF_OK;
  2362. }


  2365. #if (NGX_HTTP_CACHE)

  2367. static char *
  2368. ‌ngx_http_uwsgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2369. {
  2370.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2372.     ngx_str_t                         *value;
  2373.     ngx_http_complex_value_t           cv;
  2374.     ngx_http_compile_complex_value_t   ccv;

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

  2378.     if (uwcf->upstream.cache != NGX_CONF_UNSET) {
  2379.         return "is duplicate";
  2380.     }

  2382.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2383.         uwcf->upstream.cache = 0;
  2384.         return NGX_CONF_OK;
  2385.     }

  2387.     if (uwcf->upstream.store > 0) {
  2388.         return "is incompatible with \"uwsgi_store\"";
  2389.     }

  2391.     uwcf->upstream.cache = 1;

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

  2395.     ccv.cf = cf;
  2396.     ccv.value = &value[1];
  2397.     ccv.complex_value = &cv;

  2399.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2400.         return NGX_CONF_ERROR;
  2401.     }

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

  2405.         uwcf->upstream.cache_value = ngx_palloc(cf->pool,
  2406.                                              sizeof(ngx_http_complex_value_t));
  2407.         if (uwcf->upstream.cache_value == NULL) {
  2408.             return NGX_CONF_ERROR;
  2409.         }

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

  2413.         return NGX_CONF_OK;
  2414.     }

  2416.     uwcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2417.                                                       &ngx_http_uwsgi_module);
  2418.     if (uwcf->upstream.cache_zone == NULL) {
  2419.         return NGX_CONF_ERROR;
  2420.     }

  2422.     return NGX_CONF_OK;
  2423. }


  2426. static char *
  2427. ‌ngx_http_uwsgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2428. {
  2429.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2431.     ngx_str_t                         *value;
  2432.     ngx_http_compile_complex_value_t   ccv;

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

  2436.     if (uwcf->cache_key.value.data) {
  2437.         return "is duplicate";
  2438.     }

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

  2442.     ccv.cf = cf;
  2443.     ccv.value = &value[1];
  2444.     ccv.complex_value = &uwcf->cache_key;

  2446.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2447.         return NGX_CONF_ERROR;
  2448.     }

  2450.     return NGX_CONF_OK;
  2451. }

  2453. #endif


  2456. #if (NGX_HTTP_SSL)

  2458. static char *
  2459. ‌ngx_http_uwsgi_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2460. {
  2461.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2463.     ngx_str_t  *value;

  2465.     if (uwcf->upstream.ssl_passwords != NGX_CONF_UNSET_PTR) {
  2466.         return "is duplicate";
  2467.     }

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

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

  2473.     if (uwcf->upstream.ssl_passwords == NULL) {
  2474.         return NGX_CONF_ERROR;
  2475.     }

  2477.     return NGX_CONF_OK;
  2478. }


  2481. static char *
  2482. ‌ngx_http_uwsgi_ssl_conf_command_check(ngx_conf_t *cf, void *post, void *data)
  2483. {
  2484. #ifndef SSL_CONF_FLAG_FILE
  2485.     return "is not supported on this platform";
  2486. #else
  2487.     return NGX_CONF_OK;
  2488. #endif
  2489. }


  2492. static ngx_int_t
  2493. ‌ngx_http_uwsgi_merge_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  2494.     ngx_http_uwsgi_loc_conf_t *prev)
  2495. {
  2496.     ngx_uint_t  preserve;

  2498.     if (conf->ssl_protocols == 0
  2499.         && conf->ssl_ciphers.data == NULL
  2500.         && conf->upstream.ssl_certificate == NGX_CONF_UNSET_PTR
  2501.         && conf->upstream.ssl_certificate_key == NGX_CONF_UNSET_PTR
  2502.         && conf->upstream.ssl_passwords == NGX_CONF_UNSET_PTR
  2503.         && conf->upstream.ssl_verify == NGX_CONF_UNSET
  2504.         && conf->ssl_verify_depth == NGX_CONF_UNSET_UINT
  2505.         && conf->ssl_trusted_certificate.data == NULL
  2506.         && conf->ssl_crl.data == NULL
  2507.         && conf->upstream.ssl_session_reuse == NGX_CONF_UNSET
  2508.         && conf->ssl_conf_commands == NGX_CONF_UNSET_PTR)
  2509.     {
  2510.         if (prev->upstream.ssl) {
  2511.             conf->upstream.ssl = prev->upstream.ssl;
  2512.             return NGX_OK;
  2513.         }

  2515.         preserve = 1;

  2517.     } else {
  2518.         preserve = 0;
  2519.     }

  2521.     conf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2522.     if (conf->upstream.ssl == NULL) {
  2523.         return NGX_ERROR;
  2524.     }

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

  2528.     /*
  2529.      * special handling to preserve conf->upstream.ssl
  2530.      * in the "http" section to inherit it to all servers
  2531.      */

  2533.     if (preserve) {
  2534.         prev->upstream.ssl = conf->upstream.ssl;
  2535.     }

  2537.     return NGX_OK;
  2538. }


  2541. static ngx_int_t
  2542. ‌ngx_http_uwsgi_set_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *uwcf)
  2543. {
  2544.     ngx_pool_cleanup_t  *cln;

  2546.     if (uwcf->upstream.ssl->ctx) {
  2547.         return NGX_OK;
  2548.     }

  2550.     if (ngx_ssl_create(uwcf->upstream.ssl, uwcf->ssl_protocols, NULL)
  2551.         != NGX_OK)
  2552.     {
  2553.         return NGX_ERROR;
  2554.     }

  2556.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2557.     if (cln == NULL) {
  2558.         ngx_ssl_cleanup_ctx(uwcf->upstream.ssl);
  2559.         return NGX_ERROR;
  2560.     }

  2562.     cln->handler = ngx_ssl_cleanup_ctx;
  2563.     cln->data = uwcf->upstream.ssl;

  2565.     if (ngx_ssl_ciphers(cf, uwcf->upstream.ssl, &uwcf->ssl_ciphers, 0)
  2566.         != NGX_OK)
  2567.     {
  2568.         return NGX_ERROR;
  2569.     }

  2571.     if (uwcf->upstream.ssl_certificate
  2572.         && uwcf->upstream.ssl_certificate->value.len)
  2573.     {
  2574.         if (uwcf->upstream.ssl_certificate_key == NULL) {
  2575.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2576.                           "no \"uwsgi_ssl_certificate_key\" is defined "
  2577.                           "for certificate \"%V\"",
  2578.                           &uwcf->upstream.ssl_certificate->value);
  2579.             return NGX_ERROR;
  2580.         }

  2582.         if (uwcf->upstream.ssl_certificate->lengths
  2583.             || uwcf->upstream.ssl_certificate_key->lengths)
  2584.         {
  2585.             uwcf->upstream.ssl_passwords =
  2586.                   ngx_ssl_preserve_passwords(cf, uwcf->upstream.ssl_passwords);
  2587.             if (uwcf->upstream.ssl_passwords == NULL) {
  2588.                 return NGX_ERROR;
  2589.             }

  2591.         } else {
  2592.             if (ngx_ssl_certificate(cf, uwcf->upstream.ssl,
  2593.                                     &uwcf->upstream.ssl_certificate->value,
  2594.                                     &uwcf->upstream.ssl_certificate_key->value,
  2595.                                     uwcf->upstream.ssl_passwords)
  2596.                 != NGX_OK)
  2597.             {
  2598.                 return NGX_ERROR;
  2599.             }
  2600.         }
  2601.     }

  2603.     if (uwcf->upstream.ssl_verify) {
  2604.         if (uwcf->ssl_trusted_certificate.len == 0) {
  2605.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2606.                       "no uwsgi_ssl_trusted_certificate for uwsgi_ssl_verify");
  2607.             return NGX_ERROR;
  2608.         }

  2610.         if (ngx_ssl_trusted_certificate(cf, uwcf->upstream.ssl,
  2611.                                         &uwcf->ssl_trusted_certificate,
  2612.                                         uwcf->ssl_verify_depth)
  2613.             != NGX_OK)
  2614.         {
  2615.             return NGX_ERROR;
  2616.         }

  2618.         if (ngx_ssl_crl(cf, uwcf->upstream.ssl, &uwcf->ssl_crl) != NGX_OK) {
  2619.             return NGX_ERROR;
  2620.         }
  2621.     }

  2623.     if (ngx_ssl_client_session_cache(cf, uwcf->upstream.ssl,
  2624.                                      uwcf->upstream.ssl_session_reuse)
  2625.         != NGX_OK)
  2626.     {
  2627.         return NGX_ERROR;
  2628.     }

  2630.     if (ngx_ssl_conf_commands(cf, uwcf->upstream.ssl, uwcf->ssl_conf_commands)
  2631.         != NGX_OK)
  2632.     {
  2633.         return NGX_ERROR;
  2634.     }

  2636.     return NGX_OK;
  2637. }

  2639. #endif

One Level Up Top Level