One Level Up Top Level

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

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_str_t                  ssl_certificate;
  58.     ngx_str_t                  ssl_certificate_key;
  59.     ngx_array_t               *ssl_passwords;
  60. #endif
  61. ‌} ngx_http_uwsgi_loc_conf_t;


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

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

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

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

  95. #if (NGX_HTTP_SSL)
  96. static char *ngx_http_uwsgi_ssl_password_file(ngx_conf_t *cf,
  97.     ngx_command_t *cmd, void *conf);
  98. static ngx_int_t ngx_http_uwsgi_set_ssl(ngx_conf_t *cf,
  99.     ngx_http_uwsgi_loc_conf_t *uwcf);
  100. #endif


  103. ‌static ngx_conf_num_bounds_t  ngx_http_uwsgi_modifier_bounds = {
  104.     ngx_conf_check_num_bounds, 0, 255
  105. };


  108. ‌static ngx_conf_bitmask_t ngx_http_uwsgi_next_upstream_masks[] = {
  109.     { ngx_string("error"), NGX_HTTP_UPSTREAM_FT_ERROR },
  110.     { ngx_string("timeout"), NGX_HTTP_UPSTREAM_FT_TIMEOUT },
  111.     { ngx_string("invalid_header"), NGX_HTTP_UPSTREAM_FT_INVALID_HEADER },
  112.     { ngx_string("http_500"), NGX_HTTP_UPSTREAM_FT_HTTP_500 },
  113.     { ngx_string("http_503"), NGX_HTTP_UPSTREAM_FT_HTTP_503 },
  114.     { ngx_string("http_403"), NGX_HTTP_UPSTREAM_FT_HTTP_403 },
  115.     { ngx_string("http_404"), NGX_HTTP_UPSTREAM_FT_HTTP_404 },
  116.     { ngx_string("updating"), NGX_HTTP_UPSTREAM_FT_UPDATING },
  117.     { ngx_string("off"), NGX_HTTP_UPSTREAM_FT_OFF },
  118.     { ngx_null_string, 0 }
  119. };


  122. #if (NGX_HTTP_SSL)

  124. ‌static ngx_conf_bitmask_t  ngx_http_uwsgi_ssl_protocols[] = {
  125.     { ngx_string("SSLv2"), NGX_SSL_SSLv2 },
  126.     { ngx_string("SSLv3"), NGX_SSL_SSLv3 },
  127.     { ngx_string("TLSv1"), NGX_SSL_TLSv1 },
  128.     { ngx_string("TLSv1.1"), NGX_SSL_TLSv1_1 },
  129.     { ngx_string("TLSv1.2"), NGX_SSL_TLSv1_2 },
  130.     { ngx_null_string, 0 }
  131. };

  133. #endif


  136. ‌ngx_module_t  ngx_http_uwsgi_module;


  139. ‌static ngx_command_t ngx_http_uwsgi_commands[] = {

  141.     { ngx_string("uwsgi_pass"),
  142.       NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF|NGX_CONF_TAKE1,
  143.       ngx_http_uwsgi_pass,
  144.       NGX_HTTP_LOC_CONF_OFFSET,
  145.       0,
  146.       NULL },

  148.     { ngx_string("uwsgi_modifier1"),
  149.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  150.       ngx_conf_set_num_slot,
  151.       NGX_HTTP_LOC_CONF_OFFSET,
  152.       offsetof(ngx_http_uwsgi_loc_conf_t, modifier1),
  153.       &ngx_http_uwsgi_modifier_bounds },

  155.     { ngx_string("uwsgi_modifier2"),
  156.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  157.       ngx_conf_set_num_slot,
  158.       NGX_HTTP_LOC_CONF_OFFSET,
  159.       offsetof(ngx_http_uwsgi_loc_conf_t, modifier2),
  160.       &ngx_http_uwsgi_modifier_bounds },

  162.     { ngx_string("uwsgi_store"),
  163.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  164.       ngx_http_uwsgi_store,
  165.       NGX_HTTP_LOC_CONF_OFFSET,
  166.       0,
  167.       NULL },

  169.     { ngx_string("uwsgi_store_access"),
  170.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  171.       ngx_conf_set_access_slot,
  172.       NGX_HTTP_LOC_CONF_OFFSET,
  173.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.store_access),
  174.       NULL },

  176.     { ngx_string("uwsgi_buffering"),
  177.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  178.       ngx_conf_set_flag_slot,
  179.       NGX_HTTP_LOC_CONF_OFFSET,
  180.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.buffering),
  181.       NULL },

  183.     { ngx_string("uwsgi_ignore_client_abort"),
  184.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  185.       ngx_conf_set_flag_slot,
  186.       NGX_HTTP_LOC_CONF_OFFSET,
  187.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ignore_client_abort),
  188.       NULL },

  190.     { ngx_string("uwsgi_bind"),
  191.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  192.       ngx_http_upstream_bind_set_slot,
  193.       NGX_HTTP_LOC_CONF_OFFSET,
  194.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.local),
  195.       NULL },

  197.     { ngx_string("uwsgi_connect_timeout"),
  198.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  199.       ngx_conf_set_msec_slot,
  200.       NGX_HTTP_LOC_CONF_OFFSET,
  201.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.connect_timeout),
  202.       NULL },

  204.     { ngx_string("uwsgi_send_timeout"),
  205.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  206.       ngx_conf_set_msec_slot,
  207.       NGX_HTTP_LOC_CONF_OFFSET,
  208.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.send_timeout),
  209.       NULL },

  211.     { ngx_string("uwsgi_buffer_size"),
  212.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  213.       ngx_conf_set_size_slot,
  214.       NGX_HTTP_LOC_CONF_OFFSET,
  215.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.buffer_size),
  216.       NULL },

  218.     { ngx_string("uwsgi_pass_request_headers"),
  219.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  220.       ngx_conf_set_flag_slot,
  221.       NGX_HTTP_LOC_CONF_OFFSET,
  222.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_request_headers),
  223.       NULL },

  225.     { ngx_string("uwsgi_pass_request_body"),
  226.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  227.       ngx_conf_set_flag_slot,
  228.       NGX_HTTP_LOC_CONF_OFFSET,
  229.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_request_body),
  230.       NULL },

  232.     { ngx_string("uwsgi_intercept_errors"),
  233.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  234.       ngx_conf_set_flag_slot,
  235.       NGX_HTTP_LOC_CONF_OFFSET,
  236.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.intercept_errors),
  237.       NULL },

  239.     { ngx_string("uwsgi_read_timeout"),
  240.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  241.       ngx_conf_set_msec_slot,
  242.       NGX_HTTP_LOC_CONF_OFFSET,
  243.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.read_timeout),
  244.       NULL },

  246.     { ngx_string("uwsgi_buffers"),
  247.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  248.       ngx_conf_set_bufs_slot,
  249.       NGX_HTTP_LOC_CONF_OFFSET,
  250.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.bufs),
  251.       NULL },

  253.     { ngx_string("uwsgi_busy_buffers_size"),
  254.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  255.       ngx_conf_set_size_slot,
  256.       NGX_HTTP_LOC_CONF_OFFSET,
  257.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.busy_buffers_size_conf),
  258.       NULL },

  260.     { ngx_string("uwsgi_force_ranges"),
  261.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  262.       ngx_conf_set_flag_slot,
  263.       NGX_HTTP_LOC_CONF_OFFSET,
  264.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.force_ranges),
  265.       NULL },

  267.     { ngx_string("uwsgi_limit_rate"),
  268.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  269.       ngx_conf_set_size_slot,
  270.       NGX_HTTP_LOC_CONF_OFFSET,
  271.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.limit_rate),
  272.       NULL },

  274. #if (NGX_HTTP_CACHE)

  276.     { ngx_string("uwsgi_cache"),
  277.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  278.       ngx_http_uwsgi_cache,
  279.       NGX_HTTP_LOC_CONF_OFFSET,
  280.       0,
  281.       NULL },

  283.     { ngx_string("uwsgi_cache_key"),
  284.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  285.       ngx_http_uwsgi_cache_key,
  286.       NGX_HTTP_LOC_CONF_OFFSET,
  287.       0,
  288.       NULL },

  290.     { ngx_string("uwsgi_cache_path"),
  291.       NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  292.       ngx_http_file_cache_set_slot,
  293.       NGX_HTTP_MAIN_CONF_OFFSET,
  294.       offsetof(ngx_http_uwsgi_main_conf_t, caches),
  295.       &ngx_http_uwsgi_module },

  297.     { ngx_string("uwsgi_cache_bypass"),
  298.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  299.       ngx_http_set_predicate_slot,
  300.       NGX_HTTP_LOC_CONF_OFFSET,
  301.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_bypass),
  302.       NULL },

  304.     { ngx_string("uwsgi_no_cache"),
  305.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  306.       ngx_http_set_predicate_slot,
  307.       NGX_HTTP_LOC_CONF_OFFSET,
  308.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.no_cache),
  309.       NULL },

  311.     { ngx_string("uwsgi_cache_valid"),
  312.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  313.       ngx_http_file_cache_valid_set_slot,
  314.       NGX_HTTP_LOC_CONF_OFFSET,
  315.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_valid),
  316.       NULL },

  318.     { ngx_string("uwsgi_cache_min_uses"),
  319.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  320.       ngx_conf_set_num_slot,
  321.       NGX_HTTP_LOC_CONF_OFFSET,
  322.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_min_uses),
  323.       NULL },

  325.     { ngx_string("uwsgi_cache_use_stale"),
  326.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  327.       ngx_conf_set_bitmask_slot,
  328.       NGX_HTTP_LOC_CONF_OFFSET,
  329.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_use_stale),
  330.       &ngx_http_uwsgi_next_upstream_masks },

  332.     { ngx_string("uwsgi_cache_methods"),
  333.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  334.       ngx_conf_set_bitmask_slot,
  335.       NGX_HTTP_LOC_CONF_OFFSET,
  336.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_methods),
  337.       &ngx_http_upstream_cache_method_mask },

  339.     { ngx_string("uwsgi_cache_lock"),
  340.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  341.       ngx_conf_set_flag_slot,
  342.       NGX_HTTP_LOC_CONF_OFFSET,
  343.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock),
  344.       NULL },

  346.     { ngx_string("uwsgi_cache_lock_timeout"),
  347.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  348.       ngx_conf_set_msec_slot,
  349.       NGX_HTTP_LOC_CONF_OFFSET,
  350.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock_timeout),
  351.       NULL },

  353.     { ngx_string("uwsgi_cache_lock_age"),
  354.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  355.       ngx_conf_set_msec_slot,
  356.       NGX_HTTP_LOC_CONF_OFFSET,
  357.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_lock_age),
  358.       NULL },

  360.     { ngx_string("uwsgi_cache_revalidate"),
  361.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  362.       ngx_conf_set_flag_slot,
  363.       NGX_HTTP_LOC_CONF_OFFSET,
  364.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.cache_revalidate),
  365.       NULL },

  367. #endif

  369.     { ngx_string("uwsgi_temp_path"),
  370.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1234,
  371.       ngx_conf_set_path_slot,
  372.       NGX_HTTP_LOC_CONF_OFFSET,
  373.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.temp_path),
  374.       NULL },

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

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

  390.     { ngx_string("uwsgi_next_upstream"),
  391.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  392.       ngx_conf_set_bitmask_slot,
  393.       NGX_HTTP_LOC_CONF_OFFSET,
  394.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream),
  395.       &ngx_http_uwsgi_next_upstream_masks },

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

  404.     { ngx_string("uwsgi_next_upstream_timeout"),
  405.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  406.       ngx_conf_set_msec_slot,
  407.       NGX_HTTP_LOC_CONF_OFFSET,
  408.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.next_upstream_timeout),
  409.       NULL },

  411.     { ngx_string("uwsgi_param"),
  412.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE23,
  413.       ngx_http_upstream_param_set_slot,
  414.       NGX_HTTP_LOC_CONF_OFFSET,
  415.       offsetof(ngx_http_uwsgi_loc_conf_t, params_source),
  416.       NULL },

  418.     { ngx_string("uwsgi_string"),
  419.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  420.       ngx_conf_set_str_slot,
  421.       NGX_HTTP_LOC_CONF_OFFSET,
  422.       offsetof(ngx_http_uwsgi_loc_conf_t, uwsgi_string),
  423.       NULL },

  425.     { ngx_string("uwsgi_pass_header"),
  426.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  427.       ngx_conf_set_str_array_slot,
  428.       NGX_HTTP_LOC_CONF_OFFSET,
  429.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.pass_headers),
  430.       NULL },

  432.     { ngx_string("uwsgi_hide_header"),
  433.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  434.       ngx_conf_set_str_array_slot,
  435.       NGX_HTTP_LOC_CONF_OFFSET,
  436.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.hide_headers),
  437.       NULL },

  439.     { ngx_string("uwsgi_ignore_headers"),
  440.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  441.       ngx_conf_set_bitmask_slot,
  442.       NGX_HTTP_LOC_CONF_OFFSET,
  443.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ignore_headers),
  444.       &ngx_http_upstream_ignore_headers_masks },

  446. #if (NGX_HTTP_SSL)

  448.     { ngx_string("uwsgi_ssl_session_reuse"),
  449.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  450.       ngx_conf_set_flag_slot,
  451.       NGX_HTTP_LOC_CONF_OFFSET,
  452.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_session_reuse),
  453.       NULL },

  455.     { ngx_string("uwsgi_ssl_protocols"),
  456.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  457.       ngx_conf_set_bitmask_slot,
  458.       NGX_HTTP_LOC_CONF_OFFSET,
  459.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_protocols),
  460.       &ngx_http_uwsgi_ssl_protocols },

  462.     { ngx_string("uwsgi_ssl_ciphers"),
  463.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  464.       ngx_conf_set_str_slot,
  465.       NGX_HTTP_LOC_CONF_OFFSET,
  466.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_ciphers),
  467.       NULL },

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

  476.     { ngx_string("uwsgi_ssl_server_name"),
  477.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  478.       ngx_conf_set_flag_slot,
  479.       NGX_HTTP_LOC_CONF_OFFSET,
  480.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_server_name),
  481.       NULL },

  483.     { ngx_string("uwsgi_ssl_verify"),
  484.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  485.       ngx_conf_set_flag_slot,
  486.       NGX_HTTP_LOC_CONF_OFFSET,
  487.       offsetof(ngx_http_uwsgi_loc_conf_t, upstream.ssl_verify),
  488.       NULL },

  490.     { ngx_string("uwsgi_ssl_verify_depth"),
  491.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  492.       ngx_conf_set_num_slot,
  493.       NGX_HTTP_LOC_CONF_OFFSET,
  494.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_verify_depth),
  495.       NULL },

  497.     { ngx_string("uwsgi_ssl_trusted_certificate"),
  498.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  499.       ngx_conf_set_str_slot,
  500.       NGX_HTTP_LOC_CONF_OFFSET,
  501.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_trusted_certificate),
  502.       NULL },

  504.     { ngx_string("uwsgi_ssl_crl"),
  505.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  506.       ngx_conf_set_str_slot,
  507.       NGX_HTTP_LOC_CONF_OFFSET,
  508.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_crl),
  509.       NULL },

  511.     { ngx_string("uwsgi_ssl_certificate"),
  512.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  513.       ngx_conf_set_str_slot,
  514.       NGX_HTTP_LOC_CONF_OFFSET,
  515.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_certificate),
  516.       NULL },

  518.     { ngx_string("uwsgi_ssl_certificate_key"),
  519.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  520.       ngx_conf_set_str_slot,
  521.       NGX_HTTP_LOC_CONF_OFFSET,
  522.       offsetof(ngx_http_uwsgi_loc_conf_t, ssl_certificate_key),
  523.       NULL },

  525.     { ngx_string("uwsgi_ssl_password_file"),
  526.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  527.       ngx_http_uwsgi_ssl_password_file,
  528.       NGX_HTTP_LOC_CONF_OFFSET,
  529.       0,
  530.       NULL },

  532. #endif

  534.       ngx_null_command
  535. };


  538. ‌static ngx_http_module_t ngx_http_uwsgi_module_ctx = {
  539.     NULL,                                  /* preconfiguration */
  540.     NULL,                                  /* postconfiguration */

  542.     ngx_http_uwsgi_create_main_conf,       /* create main configuration */
  543.     NULL,                                  /* init main configuration */

  545.     NULL,                                  /* create server configuration */
  546.     NULL,                                  /* merge server configuration */

  548.     ngx_http_uwsgi_create_loc_conf,        /* create location configuration */
  549.     ngx_http_uwsgi_merge_loc_conf          /* merge location configuration */
  550. };


  553. ‌ngx_module_t ngx_http_uwsgi_module = {
  554.     NGX_MODULE_V1,
  555.     &ngx_http_uwsgi_module_ctx,            /* module context */
  556.     ngx_http_uwsgi_commands,               /* module directives */
  557.     NGX_HTTP_MODULE,                       /* module type */
  558.     NULL,                                  /* init master */
  559.     NULL,                                  /* init module */
  560.     NULL,                                  /* init process */
  561.     NULL,                                  /* init thread */
  562.     NULL,                                  /* exit thread */
  563.     NULL,                                  /* exit process */
  564.     NULL,                                  /* exit master */
  565.     NGX_MODULE_V1_PADDING
  566. };


  569. ‌static ngx_str_t ngx_http_uwsgi_hide_headers[] = {
  570.     ngx_string("X-Accel-Expires"),
  571.     ngx_string("X-Accel-Redirect"),
  572.     ngx_string("X-Accel-Limit-Rate"),
  573.     ngx_string("X-Accel-Buffering"),
  574.     ngx_string("X-Accel-Charset"),
  575.     ngx_null_string
  576. };


  579. #if (NGX_HTTP_CACHE)

  581. ‌static ngx_keyval_t  ngx_http_uwsgi_cache_headers[] = {
  582.     { ngx_string("HTTP_IF_MODIFIED_SINCE"),
  583.       ngx_string("$upstream_cache_last_modified") },
  584.     { ngx_string("HTTP_IF_UNMODIFIED_SINCE"), ngx_string("") },
  585.     { ngx_string("HTTP_IF_NONE_MATCH"), ngx_string("$upstream_cache_etag") },
  586.     { ngx_string("HTTP_IF_MATCH"), ngx_string("") },
  587.     { ngx_string("HTTP_RANGE"), ngx_string("") },
  588.     { ngx_string("HTTP_IF_RANGE"), ngx_string("") },
  589.     { ngx_null_string, ngx_null_string }
  590. };

  592. #endif


  595. ‌static ngx_path_init_t ngx_http_uwsgi_temp_path = {
  596.     ngx_string(NGX_HTTP_UWSGI_TEMP_PATH), { 1, 2, 0 }
  597. };


  600. static ngx_int_t
  601. ‌ngx_http_uwsgi_handler(ngx_http_request_t *r)
  602. {
  603.     ngx_int_t                    rc;
  604.     ngx_http_status_t           *status;
  605.     ngx_http_upstream_t         *u;
  606.     ngx_http_uwsgi_loc_conf_t   *uwcf;
  607. #if (NGX_HTTP_CACHE)
  608.     ngx_http_uwsgi_main_conf_t  *uwmcf;
  609. #endif

  611.     if (ngx_http_upstream_create(r) != NGX_OK) {
  612.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  613.     }

  615.     status = ngx_pcalloc(r->pool, sizeof(ngx_http_status_t));
  616.     if (status == NULL) {
  617.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  618.     }

  620.     ngx_http_set_ctx(r, status, ngx_http_uwsgi_module);

  622.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  624.     u = r->upstream;

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

  628. #if (NGX_HTTP_SSL)
  629.         u->ssl = (uwcf->upstream.ssl != NULL);

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

  634.         } else {
  635.             ngx_str_set(&u->schema, "uwsgi://");
  636.         }
  637. #else
  638.         ngx_str_set(&u->schema, "uwsgi://");
  639. #endif

  641.     } else {
  642.         if (ngx_http_uwsgi_eval(r, uwcf) != NGX_OK) {
  643.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  644.         }
  645.     }

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

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

  651. #if (NGX_HTTP_CACHE)
  652.     uwmcf = ngx_http_get_module_main_conf(r, ngx_http_uwsgi_module);

  654.     u->caches = &uwmcf->caches;
  655.     u->create_key = ngx_http_uwsgi_create_key;
  656. #endif

  658.     u->create_request = ngx_http_uwsgi_create_request;
  659.     u->reinit_request = ngx_http_uwsgi_reinit_request;
  660.     u->process_header = ngx_http_uwsgi_process_status_line;
  661.     u->abort_request = ngx_http_uwsgi_abort_request;
  662.     u->finalize_request = ngx_http_uwsgi_finalize_request;
  663.     r->state = 0;

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

  667.     u->pipe = ngx_pcalloc(r->pool, sizeof(ngx_event_pipe_t));
  668.     if (u->pipe == NULL) {
  669.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  670.     }

  672.     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
  673.     u->pipe->input_ctx = r;

  675.     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);

  677.     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
  678.         return rc;
  679.     }

  681.     return NGX_DONE;
  682. }


  685. static ngx_int_t
  686. ‌ngx_http_uwsgi_eval(ngx_http_request_t *r, ngx_http_uwsgi_loc_conf_t * uwcf)
  687. {
  688.     size_t                add;
  689.     ngx_url_t             url;
  690.     ngx_http_upstream_t  *u;

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

  694.     if (ngx_http_script_run(r, &url.url, uwcf->uwsgi_lengths->elts, 0,
  695.                             uwcf->uwsgi_values->elts)
  696.         == NULL)
  697.     {
  698.         return NGX_ERROR;
  699.     }

  701.     if (url.url.len > 8
  702.         && ngx_strncasecmp(url.url.data, (u_char *) "uwsgi://", 8) == 0)
  703.     {
  704.         add = 8;

  706.     } else if (url.url.len > 9
  707.                && ngx_strncasecmp(url.url.data, (u_char *) "suwsgi://", 9) == 0)
  708.     {

  710. #if (NGX_HTTP_SSL)
  711.         add = 9;
  712.         r->upstream->ssl = 1;
  713. #else
  714.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  715.                       "suwsgi protocol requires SSL support");
  716.         return NGX_ERROR;
  717. #endif

  719.     } else {
  720.         add = 0;
  721.     }

  723.     u = r->upstream;

  725.     if (add) {
  726.         u->schema.len = add;
  727.         u->schema.data = url.url.data;

  729.         url.url.data += add;
  730.         url.url.len -= add;

  732.     } else {
  733.         ngx_str_set(&u->schema, "uwsgi://");
  734.     }

  736.     url.no_resolve = 1;

  738.     if (ngx_parse_url(r->pool, &url) != NGX_OK) {
  739.         if (url.err) {
  740.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  741.                           "%s in upstream \"%V\"", url.err, &url.url);
  742.         }

  744.         return NGX_ERROR;
  745.     }

  747.     u->resolved = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_resolved_t));
  748.     if (u->resolved == NULL) {
  749.         return NGX_ERROR;
  750.     }

  752.     if (url.addrs && url.addrs[0].sockaddr) {
  753.         u->resolved->sockaddr = url.addrs[0].sockaddr;
  754.         u->resolved->socklen = url.addrs[0].socklen;
  755.         u->resolved->naddrs = 1;
  756.         u->resolved->host = url.addrs[0].name;

  758.     } else {
  759.         u->resolved->host = url.host;
  760.         u->resolved->port = url.port;
  761.         u->resolved->no_port = url.no_port;
  762.     }

  764.     return NGX_OK;
  765. }


  768. #if (NGX_HTTP_CACHE)

  770. static ngx_int_t
  771. ‌ngx_http_uwsgi_create_key(ngx_http_request_t *r)
  772. {
  773.     ngx_str_t                  *key;
  774.     ngx_http_uwsgi_loc_conf_t  *uwcf;

  776.     key = ngx_array_push(&r->cache->keys);
  777.     if (key == NULL) {
  778.         return NGX_ERROR;
  779.     }

  781.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  783.     if (ngx_http_complex_value(r, &uwcf->cache_key, key) != NGX_OK) {
  784.         return NGX_ERROR;
  785.     }

  787.     return NGX_OK;
  788. }

  790. #endif


  793. static ngx_int_t
  794. ‌ngx_http_uwsgi_create_request(ngx_http_request_t *r)
  795. {
  796.     u_char                        ch, *lowcase_key;
  797.     size_t                        key_len, val_len, len, allocated;
  798.     ngx_uint_t                    i, n, hash, skip_empty, header_params;
  799.     ngx_buf_t                    *b;
  800.     ngx_chain_t                  *cl, *body;
  801.     ngx_list_part_t              *part;
  802.     ngx_table_elt_t              *header, **ignored;
  803.     ngx_http_uwsgi_params_t      *params;
  804.     ngx_http_script_code_pt       code;
  805.     ngx_http_script_engine_t      e, le;
  806.     ngx_http_uwsgi_loc_conf_t    *uwcf;
  807.     ngx_http_script_len_code_pt   lcode;

  809.     len = 0;
  810.     header_params = 0;
  811.     ignored = NULL;

  813.     uwcf = ngx_http_get_module_loc_conf(r, ngx_http_uwsgi_module);

  815. #if (NGX_HTTP_CACHE)
  816.     params = r->upstream->cacheable ? &uwcf->params_cache : &uwcf->params;
  817. #else
  818.     params = &uwcf->params;
  819. #endif

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

  824.         ngx_http_script_flush_no_cacheable_variables(r, params->flushes);
  825.         le.flushed = 1;

  827.         le.ip = params->lengths->elts;
  828.         le.request = r;

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

  832.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  833.             key_len = lcode(&le);

  835.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  836.             skip_empty = lcode(&le);

  838.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode (&le)) {
  839.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  840.             }
  841.             le.ip += sizeof(uintptr_t);

  843.             if (skip_empty && val_len == 0) {
  844.                 continue;
  845.             }

  847.             len += 2 + key_len + 2 + val_len;
  848.         }
  849.     }

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

  853.         allocated = 0;
  854.         lowcase_key = NULL;

  856.         if (params->number) {
  857.             n = 0;
  858.             part = &r->headers_in.headers.part;

  860.             while (part) {
  861.                 n += part->nelts;
  862.                 part = part->next;
  863.             }

  865.             ignored = ngx_palloc(r->pool, n * sizeof(void *));
  866.             if (ignored == NULL) {
  867.                 return NGX_ERROR;
  868.             }
  869.         }

  871.         part = &r->headers_in.headers.part;
  872.         header = part->elts;

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

  876.             if (i >= part->nelts) {
  877.                 if (part->next == NULL) {
  878.                     break;
  879.                 }

  881.                 part = part->next;
  882.                 header = part->elts;
  883.                 i = 0;
  884.             }

  886.             if (params->number) {
  887.                 if (allocated < header[i].key.len) {
  888.                     allocated = header[i].key.len + 16;
  889.                     lowcase_key = ngx_pnalloc(r->pool, allocated);
  890.                     if (lowcase_key == NULL) {
  891.                         return NGX_ERROR;
  892.                     }
  893.                 }

  895.                 hash = 0;

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

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

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

  907.                     hash = ngx_hash(hash, ch);
  908.                     lowcase_key[n] = ch;
  909.                 }

  911.                 if (ngx_hash_find(&params->hash, hash, lowcase_key, n)) {
  912.                     ignored[header_params++] = &header[i];
  913.                     continue;
  914.                 }
  915.             }

  917.             len += 2 + sizeof("HTTP_") - 1 + header[i].key.len
  918.                  + 2 + header[i].value.len;
  919.         }
  920.     }

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

  924. #if 0
  925.     /* allow custom uwsgi packet */
  926.     if (len > 0 && len < 2) {
  927.         ngx_log_error (NGX_LOG_ALERT, r->connection->log, 0,
  928.                        "uwsgi request is too little: %uz", len);
  929.         return NGX_ERROR;
  930.     }
  931. #endif

  933.     b = ngx_create_temp_buf(r->pool, len + 4);
  934.     if (b == NULL) {
  935.         return NGX_ERROR;
  936.     }

  938.     cl = ngx_alloc_chain_link(r->pool);
  939.     if (cl == NULL) {
  940.         return NGX_ERROR;
  941.     }

  943.     cl->buf = b;

  945.     *b->last++ = (u_char) uwcf->modifier1;
  946.     *b->last++ = (u_char) (len & 0xff);
  947.     *b->last++ = (u_char) ((len >> 8) & 0xff);
  948.     *b->last++ = (u_char) uwcf->modifier2;

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

  953.         e.ip = params->values->elts;
  954.         e.pos = b->last;
  955.         e.request = r;
  956.         e.flushed = 1;

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

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

  962.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  963.             key_len = (u_char) lcode (&le);

  965.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  966.             skip_empty = lcode(&le);

  968.             for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) {
  969.                 lcode = *(ngx_http_script_len_code_pt *) le.ip;
  970.             }
  971.             le.ip += sizeof(uintptr_t);

  973.             if (skip_empty && val_len == 0) {
  974.                 e.skip = 1;

  976.                 while (*(uintptr_t *) e.ip) {
  977.                     code = *(ngx_http_script_code_pt *) e.ip;
  978.                     code((ngx_http_script_engine_t *) &e);
  979.                 }
  980.                 e.ip += sizeof(uintptr_t);

  982.                 e.skip = 0;

  984.                 continue;
  985.             }

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

  990.             code = *(ngx_http_script_code_pt *) e.ip;
  991.             code((ngx_http_script_engine_t *) & e);

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

  996.             while (*(uintptr_t *) e.ip) {
  997.                 code = *(ngx_http_script_code_pt *) e.ip;
  998.                 code((ngx_http_script_engine_t *) & e);
  999.             }

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

  1003.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1004.                            "uwsgi param: \"%*s: %*s\"",
  1005.                            key_len, e.pos - (key_len + 2 + val_len),
  1006.                            val_len, e.pos - val_len);
  1007.         }

  1009.         b->last = e.pos;
  1010.     }

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

  1014.         part = &r->headers_in.headers.part;
  1015.         header = part->elts;

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

  1019.             if (i >= part->nelts) {
  1020.                 if (part->next == NULL) {
  1021.                     break;
  1022.                 }

  1024.                 part = part->next;
  1025.                 header = part->elts;
  1026.                 i = 0;
  1027.             }

  1029.             for (n = 0; n < header_params; n++) {
  1030.                 if (&header[i] == ignored[n]) {
  1031.                     goto next;
  1032.                 }
  1033.             }

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

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

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

  1046.                 } else if (ch == '-') {
  1047.                     ch = '_';
  1048.                 }

  1050.                 *b->last++ = ch;
  1051.             }

  1053.             val_len = header[i].value.len;
  1054.             *b->last++ = (u_char) (val_len & 0xff);
  1055.             *b->last++ = (u_char) ((val_len >> 8) & 0xff);
  1056.             b->last = ngx_copy(b->last, header[i].value.data, val_len);

  1058.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1059.                            "uwsgi param: \"%*s: %*s\"",
  1060.                            key_len, b->last - (key_len + 2 + val_len),
  1061.                            val_len, b->last - val_len);
  1062.         next:

  1064.             continue;
  1065.         }
  1066.     }

  1068.     b->last = ngx_copy(b->last, uwcf->uwsgi_string.data,
  1069.                        uwcf->uwsgi_string.len);

  1071.     if (uwcf->upstream.pass_request_body) {
  1072.         body = r->upstream->request_bufs;
  1073.         r->upstream->request_bufs = cl;

  1075.         while (body) {
  1076.             b = ngx_alloc_buf(r->pool);
  1077.             if (b == NULL) {
  1078.                 return NGX_ERROR;
  1079.             }

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

  1083.             cl->next = ngx_alloc_chain_link(r->pool);
  1084.             if (cl->next == NULL) {
  1085.                 return NGX_ERROR;
  1086.             }

  1088.             cl = cl->next;
  1089.             cl->buf = b;

  1091.             body = body->next;
  1092.         }

  1094.     } else {
  1095.         r->upstream->request_bufs = cl;
  1096.     }

  1098.     cl->next = NULL;

  1100.     return NGX_OK;
  1101. }


  1104. static ngx_int_t
  1105. ‌ngx_http_uwsgi_reinit_request(ngx_http_request_t *r)
  1106. {
  1107.     ngx_http_status_t  *status;

  1109.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1111.     if (status == NULL) {
  1112.         return NGX_OK;
  1113.     }

  1115.     status->code = 0;
  1116.     status->count = 0;
  1117.     status->start = NULL;
  1118.     status->end = NULL;

  1120.     r->upstream->process_header = ngx_http_uwsgi_process_status_line;
  1121.     r->state = 0;

  1123.     return NGX_OK;
  1124. }


  1127. static ngx_int_t
  1128. ‌ngx_http_uwsgi_process_status_line(ngx_http_request_t *r)
  1129. {
  1130.     size_t                 len;
  1131.     ngx_int_t              rc;
  1132.     ngx_http_status_t     *status;
  1133.     ngx_http_upstream_t   *u;

  1135.     status = ngx_http_get_module_ctx(r, ngx_http_uwsgi_module);

  1137.     if (status == NULL) {
  1138.         return NGX_ERROR;
  1139.     }

  1141.     u = r->upstream;

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

  1145.     if (rc == NGX_AGAIN) {
  1146.         return rc;
  1147.     }

  1149.     if (rc == NGX_ERROR) {
  1150.         u->process_header = ngx_http_uwsgi_process_header;
  1151.         return ngx_http_uwsgi_process_header(r);
  1152.     }

  1154.     if (u->state && u->state->status == 0) {
  1155.         u->state->status = status->code;
  1156.     }

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

  1160.     len = status->end - status->start;
  1161.     u->headers_in.status_line.len = len;

  1163.     u->headers_in.status_line.data = ngx_pnalloc(r->pool, len);
  1164.     if (u->headers_in.status_line.data == NULL) {
  1165.         return NGX_ERROR;
  1166.     }

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

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

  1174.     u->process_header = ngx_http_uwsgi_process_header;

  1176.     return ngx_http_uwsgi_process_header(r);
  1177. }


  1180. static ngx_int_t
  1181. ‌ngx_http_uwsgi_process_header(ngx_http_request_t *r)
  1182. {
  1183.     ngx_str_t                      *status_line;
  1184.     ngx_int_t                       rc, status;
  1185.     ngx_table_elt_t                *h;
  1186.     ngx_http_upstream_t            *u;
  1187.     ngx_http_upstream_header_t     *hh;
  1188.     ngx_http_upstream_main_conf_t  *umcf;

  1190.     umcf = ngx_http_get_module_main_conf(r, ngx_http_upstream_module);

  1192.     for ( ;; ) {

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

  1196.         if (rc == NGX_OK) {

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

  1200.             h = ngx_list_push(&r->upstream->headers_in.headers);
  1201.             if (h == NULL) {
  1202.                 return NGX_ERROR;
  1203.             }

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

  1207.             h->key.len = r->header_name_end - r->header_name_start;
  1208.             h->value.len = r->header_end - r->header_start;

  1210.             h->key.data = ngx_pnalloc(r->pool,
  1211.                                       h->key.len + 1 + h->value.len + 1
  1212.                                       + h->key.len);
  1213.             if (h->key.data == NULL) {
  1214.                 return NGX_ERROR;
  1215.             }

  1217.             h->value.data = h->key.data + h->key.len + 1;
  1218.             h->lowcase_key = h->key.data + h->key.len + 1 + h->value.len + 1;

  1220.             ngx_memcpy(h->key.data, r->header_name_start, h->key.len);
  1221.             h->key.data[h->key.len] = '\0';
  1222.             ngx_memcpy(h->value.data, r->header_start, h->value.len);
  1223.             h->value.data[h->value.len] = '\0';

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

  1228.             } else {
  1229.                 ngx_strlow(h->lowcase_key, h->key.data, h->key.len);
  1230.             }

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

  1235.             if (hh && hh->handler(r, h, hh->offset) != NGX_OK) {
  1236.                 return NGX_ERROR;
  1237.             }

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

  1242.             continue;
  1243.         }

  1245.         if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

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

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

  1252.             u = r->upstream;

  1254.             if (u->headers_in.status_n) {
  1255.                 goto done;
  1256.             }

  1258.             if (u->headers_in.status) {
  1259.                 status_line = &u->headers_in.status->value;

  1261.                 status = ngx_atoi(status_line->data, 3);
  1262.                 if (status == NGX_ERROR) {
  1263.                     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1264.                                   "upstream sent invalid status \"%V\"",
  1265.                                   status_line);
  1266.                     return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1267.                 }

  1269.                 u->headers_in.status_n = status;
  1270.                 u->headers_in.status_line = *status_line;

  1272.             } else if (u->headers_in.location) {
  1273.                 u->headers_in.status_n = 302;
  1274.                 ngx_str_set(&u->headers_in.status_line,
  1275.                             "302 Moved Temporarily");

  1277.             } else {
  1278.                 u->headers_in.status_n = 200;
  1279.                 ngx_str_set(&u->headers_in.status_line, "200 OK");
  1280.             }

  1282.             if (u->state && u->state->status == 0) {
  1283.                 u->state->status = u->headers_in.status_n;
  1284.             }

  1286.         done:

  1288.             if (u->headers_in.status_n == NGX_HTTP_SWITCHING_PROTOCOLS
  1289.                 && r->headers_in.upgrade)
  1290.             {
  1291.                 u->upgrade = 1;
  1292.             }

  1294.             return NGX_OK;
  1295.         }

  1297.         if (rc == NGX_AGAIN) {
  1298.             return NGX_AGAIN;
  1299.         }

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

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

  1306.         return NGX_HTTP_UPSTREAM_INVALID_HEADER;
  1307.     }
  1308. }


  1311. static void
  1312. ‌ngx_http_uwsgi_abort_request(ngx_http_request_t *r)
  1313. {
  1314.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1315.                    "abort http uwsgi request");

  1317.     return;
  1318. }


  1321. static void
  1322. ‌ngx_http_uwsgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc)
  1323. {
  1324.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1325.                    "finalize http uwsgi request");

  1327.     return;
  1328. }


  1331. static void *
  1332. ‌ngx_http_uwsgi_create_main_conf(ngx_conf_t *cf)
  1333. {
  1334.     ngx_http_uwsgi_main_conf_t  *conf;

  1336.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_main_conf_t));
  1337.     if (conf == NULL) {
  1338.         return NULL;
  1339.     }

  1341. #if (NGX_HTTP_CACHE)
  1342.     if (ngx_array_init(&conf->caches, cf->pool, 4,
  1343.                        sizeof(ngx_http_file_cache_t *))
  1344.         != NGX_OK)
  1345.     {
  1346.         return NULL;
  1347.     }
  1348. #endif

  1350.     return conf;
  1351. }


  1354. static void *
  1355. ‌ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf)
  1356. {
  1357.     ngx_http_uwsgi_loc_conf_t  *conf;

  1359.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_uwsgi_loc_conf_t));
  1360.     if (conf == NULL) {
  1361.         return NULL;
  1362.     }

  1364.     conf->modifier1 = NGX_CONF_UNSET_UINT;
  1365.     conf->modifier2 = NGX_CONF_UNSET_UINT;

  1367.     conf->upstream.store = NGX_CONF_UNSET;
  1368.     conf->upstream.store_access = NGX_CONF_UNSET_UINT;
  1369.     conf->upstream.next_upstream_tries = NGX_CONF_UNSET_UINT;
  1370.     conf->upstream.buffering = NGX_CONF_UNSET;
  1371.     conf->upstream.ignore_client_abort = NGX_CONF_UNSET;
  1372.     conf->upstream.force_ranges = NGX_CONF_UNSET;

  1374.     conf->upstream.local = NGX_CONF_UNSET_PTR;

  1376.     conf->upstream.connect_timeout = NGX_CONF_UNSET_MSEC;
  1377.     conf->upstream.send_timeout = NGX_CONF_UNSET_MSEC;
  1378.     conf->upstream.read_timeout = NGX_CONF_UNSET_MSEC;
  1379.     conf->upstream.next_upstream_timeout = NGX_CONF_UNSET_MSEC;

  1381.     conf->upstream.send_lowat = NGX_CONF_UNSET_SIZE;
  1382.     conf->upstream.buffer_size = NGX_CONF_UNSET_SIZE;
  1383.     conf->upstream.limit_rate = NGX_CONF_UNSET_SIZE;

  1385.     conf->upstream.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
  1386.     conf->upstream.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
  1387.     conf->upstream.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;

  1389.     conf->upstream.pass_request_headers = NGX_CONF_UNSET;
  1390.     conf->upstream.pass_request_body = NGX_CONF_UNSET;

  1392. #if (NGX_HTTP_CACHE)
  1393.     conf->upstream.cache = NGX_CONF_UNSET;
  1394.     conf->upstream.cache_min_uses = NGX_CONF_UNSET_UINT;
  1395.     conf->upstream.cache_bypass = NGX_CONF_UNSET_PTR;
  1396.     conf->upstream.no_cache = NGX_CONF_UNSET_PTR;
  1397.     conf->upstream.cache_valid = NGX_CONF_UNSET_PTR;
  1398.     conf->upstream.cache_lock = NGX_CONF_UNSET;
  1399.     conf->upstream.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
  1400.     conf->upstream.cache_lock_age = NGX_CONF_UNSET_MSEC;
  1401.     conf->upstream.cache_revalidate = NGX_CONF_UNSET;
  1402. #endif

  1404.     conf->upstream.hide_headers = NGX_CONF_UNSET_PTR;
  1405.     conf->upstream.pass_headers = NGX_CONF_UNSET_PTR;

  1407.     conf->upstream.intercept_errors = NGX_CONF_UNSET;

  1409. #if (NGX_HTTP_SSL)
  1410.     conf->upstream.ssl_session_reuse = NGX_CONF_UNSET;
  1411.     conf->upstream.ssl_server_name = NGX_CONF_UNSET;
  1412.     conf->upstream.ssl_verify = NGX_CONF_UNSET;
  1413.     conf->ssl_verify_depth = NGX_CONF_UNSET_UINT;
  1414.     conf->ssl_passwords = NGX_CONF_UNSET_PTR;
  1415. #endif

  1417.     /* "uwsgi_cyclic_temp_file" is disabled */
  1418.     conf->upstream.cyclic_temp_file = 0;

  1420.     conf->upstream.change_buffering = 1;

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

  1424.     return conf;
  1425. }


  1428. static char *
  1429. ‌ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  1430. {
  1431.     ngx_http_uwsgi_loc_conf_t *prev = parent;
  1432.     ngx_http_uwsgi_loc_conf_t *conf = child;

  1434.     size_t                        size;
  1435.     ngx_int_t                     rc;
  1436.     ngx_hash_init_t               hash;
  1437.     ngx_http_core_loc_conf_t     *clcf;

  1439. #if (NGX_HTTP_CACHE)

  1441.     if (conf->upstream.store > 0) {
  1442.         conf->upstream.cache = 0;
  1443.     }

  1445.     if (conf->upstream.cache > 0) {
  1446.         conf->upstream.store = 0;
  1447.     }

  1449. #endif

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

  1454.         conf->upstream.store_lengths = prev->upstream.store_lengths;
  1455.         conf->upstream.store_values = prev->upstream.store_values;
  1456.     }

  1458.     ngx_conf_merge_uint_value(conf->upstream.store_access,
  1459.                               prev->upstream.store_access, 0600);

  1461.     ngx_conf_merge_uint_value(conf->upstream.next_upstream_tries,
  1462.                               prev->upstream.next_upstream_tries, 0);

  1464.     ngx_conf_merge_value(conf->upstream.buffering,
  1465.                               prev->upstream.buffering, 1);

  1467.     ngx_conf_merge_value(conf->upstream.ignore_client_abort,
  1468.                               prev->upstream.ignore_client_abort, 0);

  1470.     ngx_conf_merge_value(conf->upstream.force_ranges,
  1471.                               prev->upstream.force_ranges, 0);

  1473.     ngx_conf_merge_ptr_value(conf->upstream.local,
  1474.                               prev->upstream.local, NULL);

  1476.     ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
  1477.                               prev->upstream.connect_timeout, 60000);

  1479.     ngx_conf_merge_msec_value(conf->upstream.send_timeout,
  1480.                               prev->upstream.send_timeout, 60000);

  1482.     ngx_conf_merge_msec_value(conf->upstream.read_timeout,
  1483.                               prev->upstream.read_timeout, 60000);

  1485.     ngx_conf_merge_msec_value(conf->upstream.next_upstream_timeout,
  1486.                               prev->upstream.next_upstream_timeout, 0);

  1488.     ngx_conf_merge_size_value(conf->upstream.send_lowat,
  1489.                               prev->upstream.send_lowat, 0);

  1491.     ngx_conf_merge_size_value(conf->upstream.buffer_size,
  1492.                               prev->upstream.buffer_size,
  1493.                               (size_t) ngx_pagesize);

  1495.     ngx_conf_merge_size_value(conf->upstream.limit_rate,
  1496.                               prev->upstream.limit_rate, 0);


  1499.     ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
  1500.                               8, ngx_pagesize);

  1502.     if (conf->upstream.bufs.num < 2) {
  1503.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1504.                            "there must be at least 2 \"uwsgi_buffers\"");
  1505.         return NGX_CONF_ERROR;
  1506.     }


  1509.     size = conf->upstream.buffer_size;
  1510.     if (size < conf->upstream.bufs.size) {
  1511.         size = conf->upstream.bufs.size;
  1512.     }


  1515.     ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
  1516.                               prev->upstream.busy_buffers_size_conf,
  1517.                               NGX_CONF_UNSET_SIZE);

  1519.     if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
  1520.         conf->upstream.busy_buffers_size = 2 * size;
  1521.     } else {
  1522.         conf->upstream.busy_buffers_size =
  1523.             conf->upstream.busy_buffers_size_conf;
  1524.     }

  1526.     if (conf->upstream.busy_buffers_size < size) {
  1527.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1528.             "\"uwsgi_busy_buffers_size\" must be equal to or greater "
  1529.             "than the maximum of the value of \"uwsgi_buffer_size\" and "
  1530.             "one of the \"uwsgi_buffers\"");

  1532.         return NGX_CONF_ERROR;
  1533.     }

  1535.     if (conf->upstream.busy_buffers_size
  1536.         > (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
  1537.     {
  1538.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1539.             "\"uwsgi_busy_buffers_size\" must be less than "
  1540.             "the size of all \"uwsgi_buffers\" minus one buffer");

  1542.         return NGX_CONF_ERROR;
  1543.     }


  1546.     ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
  1547.                               prev->upstream.temp_file_write_size_conf,
  1548.                               NGX_CONF_UNSET_SIZE);

  1550.     if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
  1551.         conf->upstream.temp_file_write_size = 2 * size;
  1552.     } else {
  1553.         conf->upstream.temp_file_write_size =
  1554.             conf->upstream.temp_file_write_size_conf;
  1555.     }

  1557.     if (conf->upstream.temp_file_write_size < size) {
  1558.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1559.             "\"uwsgi_temp_file_write_size\" must be equal to or greater than "
  1560.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1561.             "one of the \"uwsgi_buffers\"");

  1563.         return NGX_CONF_ERROR;
  1564.     }


  1567.     ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
  1568.                               prev->upstream.max_temp_file_size_conf,
  1569.                               NGX_CONF_UNSET_SIZE);

  1571.     if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
  1572.         conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
  1573.     } else {
  1574.         conf->upstream.max_temp_file_size =
  1575.             conf->upstream.max_temp_file_size_conf;
  1576.     }

  1578.     if (conf->upstream.max_temp_file_size != 0
  1579.         && conf->upstream.max_temp_file_size < size)
  1580.     {
  1581.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1582.             "\"uwsgi_max_temp_file_size\" must be equal to zero to disable "
  1583.             "temporary files usage or must be equal to or greater than "
  1584.             "the maximum of the value of \"uwsgi_buffer_size\" and "
  1585.             "one of the \"uwsgi_buffers\"");

  1587.         return NGX_CONF_ERROR;
  1588.     }


  1591.     ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
  1592.                                  prev->upstream.ignore_headers,
  1593.                                  NGX_CONF_BITMASK_SET);


  1596.     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
  1597.                                  prev->upstream.next_upstream,
  1598.                                  (NGX_CONF_BITMASK_SET
  1599.                                   |NGX_HTTP_UPSTREAM_FT_ERROR
  1600.                                   |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

  1602.     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
  1603.         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
  1604.                                        |NGX_HTTP_UPSTREAM_FT_OFF;
  1605.     }

  1607.     if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
  1608.                                   prev->upstream.temp_path,
  1609.                                   &ngx_http_uwsgi_temp_path)
  1610.         != NGX_OK)
  1611.     {
  1612.         return NGX_CONF_ERROR;
  1613.     }

  1615. #if (NGX_HTTP_CACHE)

  1617.     if (conf->upstream.cache == NGX_CONF_UNSET) {
  1618.         ngx_conf_merge_value(conf->upstream.cache,
  1619.                               prev->upstream.cache, 0);

  1621.         conf->upstream.cache_zone = prev->upstream.cache_zone;
  1622.         conf->upstream.cache_value = prev->upstream.cache_value;
  1623.     }

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

  1628.         shm_zone = conf->upstream.cache_zone;

  1630.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1631.                            "\"uwsgi_cache\" zone \"%V\" is unknown",
  1632.                            &shm_zone->shm.name);

  1634.         return NGX_CONF_ERROR;
  1635.     }

  1637.     ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
  1638.                               prev->upstream.cache_min_uses, 1);

  1640.     ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
  1641.                               prev->upstream.cache_use_stale,
  1642.                               (NGX_CONF_BITMASK_SET
  1643.                                |NGX_HTTP_UPSTREAM_FT_OFF));

  1645.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
  1646.         conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
  1647.                                          |NGX_HTTP_UPSTREAM_FT_OFF;
  1648.     }

  1650.     if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
  1651.         conf->upstream.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
  1652.     }

  1654.     if (conf->upstream.cache_methods == 0) {
  1655.         conf->upstream.cache_methods = prev->upstream.cache_methods;
  1656.     }

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

  1660.     ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
  1661.                              prev->upstream.cache_bypass, NULL);

  1663.     ngx_conf_merge_ptr_value(conf->upstream.no_cache,
  1664.                              prev->upstream.no_cache, NULL);

  1666.     ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
  1667.                              prev->upstream.cache_valid, NULL);

  1669.     if (conf->cache_key.value.data == NULL) {
  1670.         conf->cache_key = prev->cache_key;
  1671.     }

  1673.     if (conf->upstream.cache && conf->cache_key.value.data == NULL) {
  1674.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1675.                            "no \"uwsgi_cache_key\" for \"uwsgi_cache\"");
  1676.     }

  1678.     ngx_conf_merge_value(conf->upstream.cache_lock,
  1679.                               prev->upstream.cache_lock, 0);

  1681.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_timeout,
  1682.                               prev->upstream.cache_lock_timeout, 5000);

  1684.     ngx_conf_merge_msec_value(conf->upstream.cache_lock_age,
  1685.                               prev->upstream.cache_lock_age, 5000);

  1687.     ngx_conf_merge_value(conf->upstream.cache_revalidate,
  1688.                               prev->upstream.cache_revalidate, 0);

  1690. #endif

  1692.     ngx_conf_merge_value(conf->upstream.pass_request_headers,
  1693.                          prev->upstream.pass_request_headers, 1);
  1694.     ngx_conf_merge_value(conf->upstream.pass_request_body,
  1695.                          prev->upstream.pass_request_body, 1);

  1697.     ngx_conf_merge_value(conf->upstream.intercept_errors,
  1698.                          prev->upstream.intercept_errors, 0);

  1700. #if (NGX_HTTP_SSL)

  1702.     ngx_conf_merge_value(conf->upstream.ssl_session_reuse,
  1703.                               prev->upstream.ssl_session_reuse, 1);

  1705.     ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
  1706.                                  (NGX_CONF_BITMASK_SET|NGX_SSL_SSLv3
  1707.                                   |NGX_SSL_TLSv1|NGX_SSL_TLSv1_1
  1708.                                   |NGX_SSL_TLSv1_2));

  1710.     ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
  1711.                              "DEFAULT");

  1713.     if (conf->upstream.ssl_name == NULL) {
  1714.         conf->upstream.ssl_name = prev->upstream.ssl_name;
  1715.     }

  1717.     ngx_conf_merge_value(conf->upstream.ssl_server_name,
  1718.                               prev->upstream.ssl_server_name, 0);
  1719.     ngx_conf_merge_value(conf->upstream.ssl_verify,
  1720.                               prev->upstream.ssl_verify, 0);
  1721.     ngx_conf_merge_uint_value(conf->ssl_verify_depth,
  1722.                               prev->ssl_verify_depth, 1);
  1723.     ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
  1724.                               prev->ssl_trusted_certificate, "");
  1725.     ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");

  1727.     ngx_conf_merge_str_value(conf->ssl_certificate,
  1728.                               prev->ssl_certificate, "");
  1729.     ngx_conf_merge_str_value(conf->ssl_certificate_key,
  1730.                               prev->ssl_certificate_key, "");
  1731.     ngx_conf_merge_ptr_value(conf->ssl_passwords, prev->ssl_passwords, NULL);

  1733.     if (conf->ssl && ngx_http_uwsgi_set_ssl(cf, conf) != NGX_OK) {
  1734.         return NGX_CONF_ERROR;
  1735.     }

  1737. #endif

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

  1741.     hash.max_size = 512;
  1742.     hash.bucket_size = ngx_align(64, ngx_cacheline_size);
  1743.     hash.name = "uwsgi_hide_headers_hash";

  1745.     if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
  1746.             &prev->upstream, ngx_http_uwsgi_hide_headers, &hash)
  1747.         != NGX_OK)
  1748.     {
  1749.         return NGX_CONF_ERROR;
  1750.     }

  1752.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);

  1754.     if (clcf->noname
  1755.         && conf->upstream.upstream == NULL && conf->uwsgi_lengths == NULL)
  1756.     {
  1757.         conf->upstream.upstream = prev->upstream.upstream;

  1759.         conf->uwsgi_lengths = prev->uwsgi_lengths;
  1760.         conf->uwsgi_values = prev->uwsgi_values;

  1762. #if (NGX_HTTP_SSL)
  1763.         conf->upstream.ssl = prev->upstream.ssl;
  1764. #endif
  1765.     }

  1767.     if (clcf->lmt_excpt && clcf->handler == NULL
  1768.         && (conf->upstream.upstream || conf->uwsgi_lengths))
  1769.     {
  1770.         clcf->handler = ngx_http_uwsgi_handler;
  1771.     }

  1773.     ngx_conf_merge_uint_value(conf->modifier1, prev->modifier1, 0);
  1774.     ngx_conf_merge_uint_value(conf->modifier2, prev->modifier2, 0);

  1776.     if (conf->params_source == NULL) {
  1777.         conf->params = prev->params;
  1778. #if (NGX_HTTP_CACHE)
  1779.         conf->params_cache = prev->params_cache;
  1780. #endif
  1781.         conf->params_source = prev->params_source;
  1782.     }

  1784.     rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params, NULL);
  1785.     if (rc != NGX_OK) {
  1786.         return NGX_CONF_ERROR;
  1787.     }

  1789. #if (NGX_HTTP_CACHE)

  1791.     if (conf->upstream.cache) {
  1792.         rc = ngx_http_uwsgi_init_params(cf, conf, &conf->params_cache,
  1793.                                         ngx_http_uwsgi_cache_headers);
  1794.         if (rc != NGX_OK) {
  1795.             return NGX_CONF_ERROR;
  1796.         }
  1797.     }

  1799. #endif

  1801.     return NGX_CONF_OK;
  1802. }


  1805. static ngx_int_t
  1806. ‌ngx_http_uwsgi_init_params(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *conf,
  1807.     ngx_http_uwsgi_params_t *params, ngx_keyval_t *default_params)
  1808. {
  1809.     u_char                       *p;
  1810.     size_t                        size;
  1811.     uintptr_t                    *code;
  1812.     ngx_uint_t                    i, nsrc;
  1813.     ngx_array_t                   headers_names, params_merged;
  1814.     ngx_keyval_t                 *h;
  1815.     ngx_hash_key_t               *hk;
  1816.     ngx_hash_init_t               hash;
  1817.     ngx_http_upstream_param_t    *src, *s;
  1818.     ngx_http_script_compile_t     sc;
  1819.     ngx_http_script_copy_code_t  *copy;

  1821.     if (params->hash.buckets) {
  1822.         return NGX_OK;
  1823.     }

  1825.     if (conf->params_source == NULL && default_params == NULL) {
  1826.         params->hash.buckets = (void *) 1;
  1827.         return NGX_OK;
  1828.     }

  1830.     params->lengths = ngx_array_create(cf->pool, 64, 1);
  1831.     if (params->lengths == NULL) {
  1832.         return NGX_ERROR;
  1833.     }

  1835.     params->values = ngx_array_create(cf->pool, 512, 1);
  1836.     if (params->values == NULL) {
  1837.         return NGX_ERROR;
  1838.     }

  1840.     if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
  1841.         != NGX_OK)
  1842.     {
  1843.         return NGX_ERROR;
  1844.     }

  1846.     if (conf->params_source) {
  1847.         src = conf->params_source->elts;
  1848.         nsrc = conf->params_source->nelts;

  1850.     } else {
  1851.         src = NULL;
  1852.         nsrc = 0;
  1853.     }

  1855.     if (default_params) {
  1856.         if (ngx_array_init(&params_merged, cf->temp_pool, 4,
  1857.                            sizeof(ngx_http_upstream_param_t))
  1858.             != NGX_OK)
  1859.         {
  1860.             return NGX_ERROR;
  1861.         }

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

  1865.             s = ngx_array_push(&params_merged);
  1866.             if (s == NULL) {
  1867.                 return NGX_ERROR;
  1868.             }

  1870.             *s = src[i];
  1871.         }

  1873.         h = default_params;

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

  1877.             src = params_merged.elts;
  1878.             nsrc = params_merged.nelts;

  1880.             for (i = 0; i < nsrc; i++) {
  1881.                 if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
  1882.                     goto next;
  1883.                 }
  1884.             }

  1886.             s = ngx_array_push(&params_merged);
  1887.             if (s == NULL) {
  1888.                 return NGX_ERROR;
  1889.             }

  1891.             s->key = h->key;
  1892.             s->value = h->value;
  1893.             s->skip_empty = 1;

  1895.         next:

  1897.             h++;
  1898.         }

  1900.         src = params_merged.elts;
  1901.         nsrc = params_merged.nelts;
  1902.     }

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

  1906.         if (src[i].key.len > sizeof("HTTP_") - 1
  1907.             && ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
  1908.         {
  1909.             hk = ngx_array_push(&headers_names);
  1910.             if (hk == NULL) {
  1911.                 return NGX_ERROR;
  1912.             }

  1914.             hk->key.len = src[i].key.len - 5;
  1915.             hk->key.data = src[i].key.data + 5;
  1916.             hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
  1917.             hk->value = (void *) 1;

  1919.             if (src[i].value.len == 0) {
  1920.                 continue;
  1921.             }
  1922.         }

  1924.         copy = ngx_array_push_n(params->lengths,
  1925.                                 sizeof(ngx_http_script_copy_code_t));
  1926.         if (copy == NULL) {
  1927.             return NGX_ERROR;
  1928.         }

  1930.         copy->code = (ngx_http_script_code_pt) ngx_http_script_copy_len_code;
  1931.         copy->len = src[i].key.len;

  1933.         copy = ngx_array_push_n(params->lengths,
  1934.                                 sizeof(ngx_http_script_copy_code_t));
  1935.         if (copy == NULL) {
  1936.             return NGX_ERROR;
  1937.         }

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


  1943.         size = (sizeof(ngx_http_script_copy_code_t)
  1944.                 + src[i].key.len + sizeof(uintptr_t) - 1)
  1945.                & ~(sizeof(uintptr_t) - 1);

  1947.         copy = ngx_array_push_n(params->values, size);
  1948.         if (copy == NULL) {
  1949.             return NGX_ERROR;
  1950.         }

  1952.         copy->code = ngx_http_script_copy_code;
  1953.         copy->len = src[i].key.len;

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


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

  1961.         sc.cf = cf;
  1962.         sc.source = &src[i].value;
  1963.         sc.flushes = &params->flushes;
  1964.         sc.lengths = &params->lengths;
  1965.         sc.values = &params->values;

  1967.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  1968.             return NGX_ERROR;
  1969.         }

  1971.         code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1972.         if (code == NULL) {
  1973.             return NGX_ERROR;
  1974.         }

  1976.         *code = (uintptr_t) NULL;


  1979.         code = ngx_array_push_n(params->values, sizeof(uintptr_t));
  1980.         if (code == NULL) {
  1981.             return NGX_ERROR;
  1982.         }

  1984.         *code = (uintptr_t) NULL;
  1985.     }

  1987.     code = ngx_array_push_n(params->lengths, sizeof(uintptr_t));
  1988.     if (code == NULL) {
  1989.         return NGX_ERROR;
  1990.     }

  1992.     *code = (uintptr_t) NULL;

  1994.     params->number = headers_names.nelts;

  1996.     hash.hash = &params->hash;
  1997.     hash.key = ngx_hash_key_lc;
  1998.     hash.max_size = 512;
  1999.     hash.bucket_size = 64;
  2000.     hash.name = "uwsgi_params_hash";
  2001.     hash.pool = cf->pool;
  2002.     hash.temp_pool = NULL;

  2004.     return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  2005. }


  2008. static char *
  2009. ‌ngx_http_uwsgi_pass(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2010. {
  2011.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2013.     size_t                      add;
  2014.     ngx_url_t                   u;
  2015.     ngx_str_t                  *value, *url;
  2016.     ngx_uint_t                  n;
  2017.     ngx_http_core_loc_conf_t   *clcf;
  2018.     ngx_http_script_compile_t   sc;

  2020.     if (uwcf->upstream.upstream || uwcf->uwsgi_lengths) {
  2021.         return "is duplicate";
  2022.     }

  2024.     clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
  2025.     clcf->handler = ngx_http_uwsgi_handler;

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

  2029.     url = &value[1];

  2031.     n = ngx_http_script_variables_count(url);

  2033.     if (n) {

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

  2037.         sc.cf = cf;
  2038.         sc.source = url;
  2039.         sc.lengths = &uwcf->uwsgi_lengths;
  2040.         sc.values = &uwcf->uwsgi_values;
  2041.         sc.variables = n;
  2042.         sc.complete_lengths = 1;
  2043.         sc.complete_values = 1;

  2045.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  2046.             return NGX_CONF_ERROR;
  2047.         }

  2049. #if (NGX_HTTP_SSL)
  2050.         uwcf->ssl = 1;
  2051. #endif

  2053.         return NGX_CONF_OK;
  2054.     }

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

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

  2061. #if (NGX_HTTP_SSL)
  2062.         add = 9;
  2063.         uwcf->ssl = 1;
  2064. #else
  2065.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2066.                            "suwsgi protocol requires SSL support");
  2067.         return NGX_CONF_ERROR;
  2068. #endif

  2070.     } else {
  2071.         add = 0;
  2072.     }

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

  2076.     u.url.len = url->len - add;
  2077.     u.url.data = url->data + add;
  2078.     u.no_resolve = 1;

  2080.     uwcf->upstream.upstream = ngx_http_upstream_add(cf, &u, 0);
  2081.     if (uwcf->upstream.upstream == NULL) {
  2082.         return NGX_CONF_ERROR;
  2083.     }

  2085.     if (clcf->name.data[clcf->name.len - 1] == '/') {
  2086.         clcf->auto_redirect = 1;
  2087.     }

  2089.     return NGX_CONF_OK;
  2090. }


  2093. static char *
  2094. ‌ngx_http_uwsgi_store(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2095. {
  2096.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2098.     ngx_str_t                  *value;
  2099.     ngx_http_script_compile_t   sc;

  2101.     if (uwcf->upstream.store != NGX_CONF_UNSET) {
  2102.         return "is duplicate";
  2103.     }

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

  2107.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2108.         uwcf->upstream.store = 0;
  2109.         return NGX_CONF_OK;
  2110.     }

  2112. #if (NGX_HTTP_CACHE)

  2114.     if (uwcf->upstream.cache > 0) {
  2115.         return "is incompatible with \"uwsgi_cache\"";
  2116.     }

  2118. #endif

  2120.     uwcf->upstream.store = 1;

  2122.     if (ngx_strcmp(value[1].data, "on") == 0) {
  2123.         return NGX_CONF_OK;
  2124.     }

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

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

  2131.     sc.cf = cf;
  2132.     sc.source = &value[1];
  2133.     sc.lengths = &uwcf->upstream.store_lengths;
  2134.     sc.values = &uwcf->upstream.store_values;
  2135.     sc.variables = ngx_http_script_variables_count(&value[1]);
  2136.     sc.complete_lengths = 1;
  2137.     sc.complete_values = 1;

  2139.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  2140.         return NGX_CONF_ERROR;
  2141.     }

  2143.     return NGX_CONF_OK;
  2144. }


  2147. #if (NGX_HTTP_CACHE)

  2149. static char *
  2150. ‌ngx_http_uwsgi_cache(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2151. {
  2152.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2154.     ngx_str_t                         *value;
  2155.     ngx_http_complex_value_t           cv;
  2156.     ngx_http_compile_complex_value_t   ccv;

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

  2160.     if (uwcf->upstream.cache != NGX_CONF_UNSET) {
  2161.         return "is duplicate";
  2162.     }

  2164.     if (ngx_strcmp(value[1].data, "off") == 0) {
  2165.         uwcf->upstream.cache = 0;
  2166.         return NGX_CONF_OK;
  2167.     }

  2169.     if (uwcf->upstream.store > 0) {
  2170.         return "is incompatible with \"uwsgi_store\"";
  2171.     }

  2173.     uwcf->upstream.cache = 1;

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

  2177.     ccv.cf = cf;
  2178.     ccv.value = &value[1];
  2179.     ccv.complex_value = &cv;

  2181.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2182.         return NGX_CONF_ERROR;
  2183.     }

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

  2187.         uwcf->upstream.cache_value = ngx_palloc(cf->pool,
  2188.                                              sizeof(ngx_http_complex_value_t));
  2189.         if (uwcf->upstream.cache_value == NULL) {
  2190.             return NGX_CONF_ERROR;
  2191.         }

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

  2195.         return NGX_CONF_OK;
  2196.     }

  2198.     uwcf->upstream.cache_zone = ngx_shared_memory_add(cf, &value[1], 0,
  2199.                                                       &ngx_http_uwsgi_module);
  2200.     if (uwcf->upstream.cache_zone == NULL) {
  2201.         return NGX_CONF_ERROR;
  2202.     }

  2204.     return NGX_CONF_OK;
  2205. }


  2208. static char *
  2209. ‌ngx_http_uwsgi_cache_key(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2210. {
  2211.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2213.     ngx_str_t                         *value;
  2214.     ngx_http_compile_complex_value_t   ccv;

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

  2218.     if (uwcf->cache_key.value.data) {
  2219.         return "is duplicate";
  2220.     }

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

  2224.     ccv.cf = cf;
  2225.     ccv.value = &value[1];
  2226.     ccv.complex_value = &uwcf->cache_key;

  2228.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  2229.         return NGX_CONF_ERROR;
  2230.     }

  2232.     return NGX_CONF_OK;
  2233. }

  2235. #endif


  2238. #if (NGX_HTTP_SSL)

  2240. static char *
  2241. ‌ngx_http_uwsgi_ssl_password_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2242. {
  2243.     ngx_http_uwsgi_loc_conf_t *uwcf = conf;

  2245.     ngx_str_t  *value;

  2247.     if (uwcf->ssl_passwords != NGX_CONF_UNSET_PTR) {
  2248.         return "is duplicate";
  2249.     }

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

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

  2255.     if (uwcf->ssl_passwords == NULL) {
  2256.         return NGX_CONF_ERROR;
  2257.     }

  2259.     return NGX_CONF_OK;
  2260. }


  2263. static ngx_int_t
  2264. ‌ngx_http_uwsgi_set_ssl(ngx_conf_t *cf, ngx_http_uwsgi_loc_conf_t *uwcf)
  2265. {
  2266.     ngx_pool_cleanup_t  *cln;

  2268.     uwcf->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));
  2269.     if (uwcf->upstream.ssl == NULL) {
  2270.         return NGX_ERROR;
  2271.     }

  2273.     uwcf->upstream.ssl->log = cf->log;

  2275.     if (ngx_ssl_create(uwcf->upstream.ssl, uwcf->ssl_protocols, NULL)
  2276.         != NGX_OK)
  2277.     {
  2278.         return NGX_ERROR;
  2279.     }

  2281.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  2282.     if (cln == NULL) {
  2283.         return NGX_ERROR;
  2284.     }

  2286.     cln->handler = ngx_ssl_cleanup_ctx;
  2287.     cln->data = uwcf->upstream.ssl;

  2289.     if (uwcf->ssl_certificate.len) {

  2291.         if (uwcf->ssl_certificate_key.len == 0) {
  2292.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2293.                           "no \"uwsgi_ssl_certificate_key\" is defined "
  2294.                           "for certificate \"%V\"", &uwcf->ssl_certificate);
  2295.             return NGX_ERROR;
  2296.         }

  2298.         if (ngx_ssl_certificate(cf, uwcf->upstream.ssl, &uwcf->ssl_certificate,
  2299.                                 &uwcf->ssl_certificate_key, uwcf->ssl_passwords)
  2300.             != NGX_OK)
  2301.         {
  2302.             return NGX_ERROR;
  2303.         }
  2304.     }

  2306.     if (SSL_CTX_set_cipher_list(uwcf->upstream.ssl->ctx,
  2307.                                 (const char *) uwcf->ssl_ciphers.data)
  2308.         == 0)
  2309.     {
  2310.         ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
  2311.                       "SSL_CTX_set_cipher_list(\"%V\") failed",
  2312.                       &uwcf->ssl_ciphers);
  2313.         return NGX_ERROR;
  2314.     }

  2316.     if (uwcf->upstream.ssl_verify) {
  2317.         if (uwcf->ssl_trusted_certificate.len == 0) {
  2318.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  2319.                       "no uwsgi_ssl_trusted_certificate for uwsgi_ssl_verify");
  2320.             return NGX_ERROR;
  2321.         }

  2323.         if (ngx_ssl_trusted_certificate(cf, uwcf->upstream.ssl,
  2324.                                         &uwcf->ssl_trusted_certificate,
  2325.                                         uwcf->ssl_verify_depth)
  2326.             != NGX_OK)
  2327.         {
  2328.             return NGX_ERROR;
  2329.         }

  2331.         if (ngx_ssl_crl(cf, uwcf->upstream.ssl, &uwcf->ssl_crl) != NGX_OK) {
  2332.             return NGX_ERROR;
  2333.         }
  2334.     }

  2336.     return NGX_OK;
  2337. }

  2339. #endif

One Level Up Top Level