static char *
ngx_http_subs_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_subs_loc_conf_t *prev = parent;
ngx_http_subs_loc_conf_t *conf = child;
if (conf->sub_pairs == NULL) {
if (prev->sub_pairs == NULL) {
conf->sub_pairs = ngx_array_create(cf->pool, 4, sizeof(sub_pair_t));
if (conf->sub_pairs == NULL) {
return NGX_CONF_ERROR;
}
} else {
conf->sub_pairs = prev->sub_pairs;
}
}
if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
&prev->types_keys, &prev->types,
ngx_http_html_default_types)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->line_buffer_size,
prev->line_buffer_size, 8 * ngx_pagesize);
/* Default total buffer size is 128k */
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
(128 * 1024) / ngx_pagesize, ngx_pagesize);
return NGX_CONF_OK;
}
static char *
ngx_http_gzip_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_gzip_conf_t *prev = parent;
ngx_http_gzip_conf_t *conf = child;
ngx_conf_merge_value(conf->enable, prev->enable, 0);
ngx_conf_merge_value(conf->no_buffer, prev->no_buffer, 0);
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
(128 * 1024) / ngx_pagesize, ngx_pagesize);
ngx_conf_merge_size_value(conf->postpone_gzipping, prev->postpone_gzipping,
0);
ngx_conf_merge_value(conf->level, prev->level, 1);
ngx_conf_merge_size_value(conf->wbits, prev->wbits, MAX_WBITS);
ngx_conf_merge_size_value(conf->memlevel, prev->memlevel,
MAX_MEM_LEVEL - 1);
ngx_conf_merge_value(conf->min_length, prev->min_length, 20);
if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
&prev->types_keys, &prev->types,
ngx_http_html_default_types)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
static char *
ngx_http_copy_filter_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_copy_filter_conf_t *prev = parent;
ngx_http_copy_filter_conf_t *conf = child;
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs, 1, 32768);
return NULL;
}
static char *
ngx_http_gunzip_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_gunzip_conf_t *prev = parent;
ngx_http_gunzip_conf_t *conf = child;
ngx_conf_merge_value(conf->enable, prev->enable, 0);
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
(128 * 1024) / ngx_pagesize, ngx_pagesize);
return NGX_CONF_OK;
}
static char *
ngx_http_gunzip_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_gunzip_conf_t *prev = parent;
ngx_http_gunzip_conf_t *conf = child;
ngx_conf_merge_value(conf->enable, prev->enable,
NGX_HTTP_GUNZIP_OFF);
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
(128 * 1024) / ngx_pagesize, ngx_pagesize);
if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
&prev->types_keys, &prev->types,
ngx_http_html_default_types)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
static char *
ngx_http_brotli_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_brotli_conf_t *prev = parent;
ngx_http_brotli_conf_t *conf = child;
ngx_conf_merge_value(conf->enable, prev->enable, 0);
ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
(128 * 1024) / ngx_pagesize, ngx_pagesize);
ngx_conf_merge_value(conf->level, prev->level, 6);
ngx_conf_merge_value(conf->min_length, prev->min_length, 2048);
if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
&prev->types_keys, &prev->types,
ngx_http_html_default_types)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
char *
passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
passenger_loc_conf_t *prev = parent;
passenger_loc_conf_t *conf = child;
u_char *p;
size_t size;
uintptr_t *code;
ngx_uint_t i;
ngx_str_t *prev_base_uris, *base_uri;
ngx_str_t *prev_union_station_filters, *union_station_filter;
ngx_keyval_t *src;
ngx_hash_init_t hash;
ngx_http_script_compile_t sc;
ngx_http_script_copy_code_t *copy;
#include "MergeLocationConfig.c"
if (prev->options_cache.data == NULL) {
cache_loc_conf_options(cf, prev);
}
cache_loc_conf_options(cf, conf);
if (prev->base_uris != NGX_CONF_UNSET_PTR) {
if (conf->base_uris == NGX_CONF_UNSET_PTR) {
conf->base_uris = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
if (conf->base_uris == NULL) {
return NGX_CONF_ERROR;
}
}
prev_base_uris = (ngx_str_t *) prev->base_uris->elts;
for (i = 0; i < prev->base_uris->nelts; i++) {
base_uri = (ngx_str_t *) ngx_array_push(conf->base_uris);
if (base_uri == NULL) {
return NGX_CONF_ERROR;
}
*base_uri = prev_base_uris[i];
}
}
if (prev->union_station_filters != NGX_CONF_UNSET_PTR) {
if (conf->union_station_filters == NGX_CONF_UNSET_PTR) {
conf->union_station_filters = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
if (conf->union_station_filters == NULL) {
return NGX_CONF_ERROR;
}
}
prev_union_station_filters = (ngx_str_t *) prev->union_station_filters->elts;
for (i = 0; i < prev->union_station_filters->nelts; i++) {
union_station_filter = (ngx_str_t *) ngx_array_push(conf->union_station_filters);
if (union_station_filter == NULL) {
return NGX_CONF_ERROR;
}
*union_station_filter = prev_union_station_filters[i];
}
}
/******************************/
/******************************/
if (conf->upstream_config.store != 0) {
ngx_conf_merge_value(conf->upstream_config.store,
prev->upstream_config.store, 0);
if (conf->upstream_config.store_lengths == NULL) {
conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
conf->upstream_config.store_values = prev->upstream_config.store_values;
}
}
ngx_conf_merge_uint_value(conf->upstream_config.store_access,
prev->upstream_config.store_access, 0600);
ngx_conf_merge_value(conf->upstream_config.buffering,
prev->upstream_config.buffering, 0);
ngx_conf_merge_value(conf->upstream_config.ignore_client_abort,
prev->upstream_config.ignore_client_abort, 0);
ngx_conf_merge_ptr_value(conf->upstream_config.local,
prev->upstream_config.local, NULL);
ngx_conf_merge_msec_value(conf->upstream_config.connect_timeout,
prev->upstream_config.connect_timeout, 12000000);
ngx_conf_merge_msec_value(conf->upstream_config.send_timeout,
prev->upstream_config.send_timeout, 12000000);
ngx_conf_merge_msec_value(conf->upstream_config.read_timeout,
prev->upstream_config.read_timeout, 12000000);
ngx_conf_merge_size_value(conf->upstream_config.send_lowat,
prev->upstream_config.send_lowat, 0);
ngx_conf_merge_size_value(conf->upstream_config.buffer_size,
prev->upstream_config.buffer_size,
16 * 1024);
ngx_conf_merge_bufs_value(conf->upstream_config.bufs, prev->upstream_config.bufs,
8, 16 * 1024);
if (conf->upstream_config.bufs.num < 2) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"there must be at least 2 \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
size = conf->upstream_config.buffer_size;
if (size < conf->upstream_config.bufs.size) {
size = conf->upstream_config.bufs.size;
}
ngx_conf_merge_size_value(conf->upstream_config.busy_buffers_size_conf,
prev->upstream_config.busy_buffers_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.busy_buffers_size = 2 * size;
} else {
conf->upstream_config.busy_buffers_size =
conf->upstream_config.busy_buffers_size_conf;
}
if (conf->upstream_config.busy_buffers_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_busy_buffers_size\" must be equal to or greater "
"than the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
if (conf->upstream_config.busy_buffers_size
> (conf->upstream_config.bufs.num - 1) * conf->upstream_config.bufs.size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_busy_buffers_size\" must be less than "
"the size of all \"passenger_buffers\" minus one buffer");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream_config.temp_file_write_size_conf,
prev->upstream_config.temp_file_write_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.temp_file_write_size = 2 * size;
} else {
conf->upstream_config.temp_file_write_size =
conf->upstream_config.temp_file_write_size_conf;
}
if (conf->upstream_config.temp_file_write_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_temp_file_write_size\" must be equal to or greater than "
"the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream_config.max_temp_file_size_conf,
prev->upstream_config.max_temp_file_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.max_temp_file_size = 1024 * 1024 * 1024;
} else {
conf->upstream_config.max_temp_file_size =
conf->upstream_config.max_temp_file_size_conf;
}
if (conf->upstream_config.max_temp_file_size != 0
&& conf->upstream_config.max_temp_file_size < size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_max_temp_file_size\" must be equal to zero to disable "
"temporary files usage or must be equal to or greater than "
"the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_bitmask_value(conf->upstream_config.ignore_headers,
prev->upstream_config.ignore_headers,
NGX_CONF_BITMASK_SET);
ngx_conf_merge_bitmask_value(conf->upstream_config.next_upstream,
prev->upstream_config.next_upstream,
(NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_ERROR
|NGX_HTTP_UPSTREAM_FT_TIMEOUT));
if (conf->upstream_config.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream_config.next_upstream = NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF;
}
ngx_conf_merge_path_value(cf,
&conf->upstream_config.temp_path,
prev->upstream_config.temp_path,
&ngx_http_proxy_temp_path);
#if (NGX_HTTP_CACHE)
ngx_conf_merge_ptr_value(conf->upstream_config.cache,
prev->upstream_config.cache, NULL);
if (conf->upstream_config.cache && conf->upstream_config.cache->data == NULL) {
ngx_shm_zone_t *shm_zone;
shm_zone = conf->upstream_config.cache;
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_cache\" zone \"%V\" is unknown",
&shm_zone->shm.name);
return NGX_CONF_ERROR;
}
ngx_conf_merge_uint_value(conf->upstream_config.cache_min_uses,
prev->upstream_config.cache_min_uses, 1);
ngx_conf_merge_bitmask_value(conf->upstream_config.cache_use_stale,
prev->upstream_config.cache_use_stale,
(NGX_CONF_BITMASK_SET
| NGX_HTTP_UPSTREAM_FT_OFF));
if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream_config.cache_use_stale = NGX_CONF_BITMASK_SET
| NGX_HTTP_UPSTREAM_FT_OFF;
}
if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
conf->upstream_config.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
}
if (conf->upstream_config.cache_methods == 0) {
conf->upstream_config.cache_methods = prev->upstream_config.cache_methods;
}
conf->upstream_config.cache_methods |= NGX_HTTP_GET | NGX_HTTP_HEAD;
ngx_conf_merge_ptr_value(conf->upstream_config.cache_bypass,
prev->upstream_config.cache_bypass, NULL);
ngx_conf_merge_ptr_value(conf->upstream_config.no_cache,
prev->upstream_config.no_cache, NULL);
ngx_conf_merge_ptr_value(conf->upstream_config.cache_valid,
prev->upstream_config.cache_valid, NULL);
if (conf->cache_key.value.data == NULL) {
conf->cache_key = prev->cache_key;
}
#if NGINX_VERSION_NUM >= 1002000
ngx_conf_merge_value(conf->upstream_config.cache_lock,
prev->upstream_config.cache_lock, 0);
ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_timeout,
prev->upstream_config.cache_lock_timeout, 5000);
#endif
#endif
ngx_conf_merge_value(conf->upstream_config.pass_request_headers,
prev->upstream_config.pass_request_headers, 1);
ngx_conf_merge_value(conf->upstream_config.pass_request_body,
prev->upstream_config.pass_request_body, 1);
ngx_conf_merge_value(conf->upstream_config.intercept_errors,
prev->upstream_config.intercept_errors, 0);
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "passenger_hide_headers_hash";
if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream_config,
&prev->upstream_config, headers_to_hide, &hash)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (conf->upstream_config.upstream == NULL) {
conf->upstream_config.upstream = prev->upstream_config.upstream;
}
if (conf->vars_source == NULL) {
conf->flushes = prev->flushes;
conf->vars_len = prev->vars_len;
conf->vars = prev->vars;
conf->vars_source = prev->vars_source;
if (conf->vars_source == NULL) {
return NGX_CONF_OK;
}
}
conf->vars_len = ngx_array_create(cf->pool, 64, 1);
if (conf->vars_len == NULL) {
return NGX_CONF_ERROR;
}
conf->vars = ngx_array_create(cf->pool, 512, 1);
if (conf->vars == NULL) {
return NGX_CONF_ERROR;
}
src = conf->vars_source->elts;
for (i = 0; i < conf->vars_source->nelts; i++) {
if (ngx_http_script_variables_count(&src[i].value) == 0) {
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len;
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].value.len;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + src[i].value.len
+ sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->vars, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len + src[i].value.len;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
ngx_memcpy(p, src[i].value.data, src[i].value.len);
} else {
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->vars, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
ngx_memcpy(p, src[i].key.data, src[i].key.len);
ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
sc.cf = cf;
sc.source = &src[i].value;
sc.flushes = &conf->flushes;
sc.lengths = &conf->vars_len;
sc.values = &conf->vars;
if (ngx_http_script_compile(&sc) != NGX_OK) {
return NGX_CONF_ERROR;
}
}
code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
code = ngx_array_push_n(conf->vars, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
}
code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
return NGX_CONF_OK;
}
char *
passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
passenger_loc_conf_t *prev = parent;
passenger_loc_conf_t *conf = child;
u_char *p;
size_t size;
uintptr_t *code;
ngx_str_t *header;
ngx_uint_t i, j;
ngx_array_t hide_headers;
ngx_str_t *prev_base_uris, *base_uri;
ngx_keyval_t *src;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
ngx_http_script_compile_t sc;
ngx_http_script_copy_code_t *copy;
#if NGINX_VERSION_NUM < 7000
u_char *temp_path;
#endif
ngx_conf_merge_value(conf->enabled, prev->enabled, 0);
ngx_conf_merge_value(conf->use_global_queue, prev->use_global_queue, 0);
ngx_conf_merge_str_value(conf->environment, prev->environment, "production");
ngx_conf_merge_str_value(conf->spawn_method, prev->spawn_method, "smart-lv2");
if (conf->framework_spawner_idle_time == -1 && prev->framework_spawner_idle_time != -1) {
conf->framework_spawner_idle_time = prev->framework_spawner_idle_time;
}
if (conf->app_spawner_idle_time == -1 && prev->app_spawner_idle_time != -1) {
conf->app_spawner_idle_time = prev->app_spawner_idle_time;
}
if (prev->base_uris != NGX_CONF_UNSET_PTR) {
if (conf->base_uris == NGX_CONF_UNSET_PTR) {
conf->base_uris = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
if (conf->base_uris == NULL) {
return NGX_CONF_ERROR;
}
}
prev_base_uris = (ngx_str_t *) prev->base_uris->elts;
for (i = 0; i < prev->base_uris->nelts; i++) {
base_uri = (ngx_str_t *) ngx_array_push(conf->base_uris);
if (base_uri == NULL) {
return NGX_CONF_ERROR;
}
*base_uri = prev_base_uris[i];
}
}
if (conf->upstream.store != 0) {
ngx_conf_merge_value(conf->upstream.store,
prev->upstream.store, 0);
if (conf->upstream.store_lengths == NULL) {
conf->upstream.store_lengths = prev->upstream.store_lengths;
conf->upstream.store_values = prev->upstream.store_values;
}
}
ngx_conf_merge_uint_value(conf->upstream.store_access,
prev->upstream.store_access, 0600);
ngx_conf_merge_value(conf->upstream.buffering,
prev->upstream.buffering, 1);
ngx_conf_merge_value(conf->upstream.ignore_client_abort,
prev->upstream.ignore_client_abort, 0);
ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
prev->upstream.connect_timeout, 60000);
ngx_conf_merge_msec_value(conf->upstream.send_timeout,
prev->upstream.send_timeout, 60000);
ngx_conf_merge_msec_value(conf->upstream.read_timeout,
prev->upstream.read_timeout, 60000);
ngx_conf_merge_size_value(conf->upstream.send_lowat,
prev->upstream.send_lowat, 0);
ngx_conf_merge_size_value(conf->upstream.buffer_size,
prev->upstream.buffer_size,
(size_t) ngx_pagesize);
ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
8, ngx_pagesize);
if (conf->upstream.bufs.num < 2) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"there must be at least 2 \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
size = conf->upstream.buffer_size;
if (size < conf->upstream.bufs.size) {
size = conf->upstream.bufs.size;
}
ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
prev->upstream.busy_buffers_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream.busy_buffers_size = 2 * size;
} else {
conf->upstream.busy_buffers_size =
conf->upstream.busy_buffers_size_conf;
}
if (conf->upstream.busy_buffers_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_busy_buffers_size\" must be equal or bigger than "
"maximum of the value of \"scgi_buffer_size\" and "
"one of the \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
if (conf->upstream.busy_buffers_size
> (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_busy_buffers_size\" must be less than "
"the size of all \"scgi_buffers\" minus one buffer");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
prev->upstream.temp_file_write_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream.temp_file_write_size = 2 * size;
} else {
conf->upstream.temp_file_write_size =
conf->upstream.temp_file_write_size_conf;
}
if (conf->upstream.temp_file_write_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_temp_file_write_size\" must be equal or bigger than "
"maximum of the value of \"scgi_buffer_size\" and "
"one of the \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
prev->upstream.max_temp_file_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
} else {
conf->upstream.max_temp_file_size =
conf->upstream.max_temp_file_size_conf;
}
if (conf->upstream.max_temp_file_size != 0
&& conf->upstream.max_temp_file_size < size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_max_temp_file_size\" must be equal to zero to disable "
"the temporary files usage or must be equal or bigger than "
"maximum of the value of \"scgi_buffer_size\" and "
"one of the \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
prev->upstream.next_upstream,
(NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_ERROR
|NGX_HTTP_UPSTREAM_FT_TIMEOUT));
if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF;
}
#if NGINX_VERSION_NUM < 7000
temp_path = ngx_palloc(cf->pool, NGX_MAX_PATH);
ngx_memzero(temp_path, NGX_MAX_PATH);
ngx_snprintf(temp_path, NGX_MAX_PATH, "%s/webserver_private", passenger_temp_dir);
ngx_conf_merge_path_value(conf->upstream.temp_path,
prev->upstream.temp_path,
temp_path, 1, 2, 0,
ngx_garbage_collector_temp_handler, cf);
conf->upstream.temp_path->name.len = ngx_strlen(conf->upstream.temp_path->name.data);
#else
ngx_conf_merge_path_value(cf,
&conf->upstream.temp_path,
prev->upstream.temp_path,
&ngx_http_proxy_temp_path);
#endif
ngx_conf_merge_value(conf->upstream.pass_request_headers,
prev->upstream.pass_request_headers, 1);
ngx_conf_merge_value(conf->upstream.pass_request_body,
prev->upstream.pass_request_body, 1);
ngx_conf_merge_value(conf->upstream.intercept_errors,
prev->upstream.intercept_errors, 0);
ngx_conf_merge_str_value(conf->index, prev->index, "");
if (conf->upstream.hide_headers == NULL
&& conf->upstream.pass_headers == NULL)
{
conf->upstream.hide_headers = prev->upstream.hide_headers;
conf->upstream.pass_headers = prev->upstream.pass_headers;
conf->upstream.hide_headers_hash = prev->upstream.hide_headers_hash;
if (conf->upstream.hide_headers_hash.buckets) {
goto peers;
}
} else {
if (conf->upstream.hide_headers == NULL) {
conf->upstream.hide_headers = prev->upstream.hide_headers;
}
if (conf->upstream.pass_headers == NULL) {
conf->upstream.pass_headers = prev->upstream.pass_headers;
}
}
if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
for (header = headers_to_hide; header->len; header++) {
hk = ngx_array_push(&hide_headers);
if (hk == NULL) {
return NGX_CONF_ERROR;
}
hk->key = *header;
hk->key_hash = ngx_hash_key_lc(header->data, header->len);
hk->value = (void *) 1;
}
if (conf->upstream.hide_headers) {
header = conf->upstream.hide_headers->elts;
for (i = 0; i < conf->upstream.hide_headers->nelts; i++) {
hk = hide_headers.elts;
for (j = 0; j < hide_headers.nelts; j++) {
if (ngx_strcasecmp(header[i].data, hk[j].key.data) == 0) {
goto exist;
}
}
hk = ngx_array_push(&hide_headers);
if (hk == NULL) {
return NGX_CONF_ERROR;
}
hk->key = header[i];
hk->key_hash = ngx_hash_key_lc(header[i].data, header[i].len);
hk->value = (void *) 1;
exist:
continue;
}
}
if (conf->upstream.pass_headers) {
hk = hide_headers.elts;
header = conf->upstream.pass_headers->elts;
for (i = 0; i < conf->upstream.pass_headers->nelts; i++) {
for (j = 0; j < hide_headers.nelts; j++) {
if (hk[j].key.data == NULL) {
continue;
}
if (ngx_strcasecmp(header[i].data, hk[j].key.data) == 0) {
hk[j].key.data = NULL;
break;
}
}
}
}
hash.hash = &conf->upstream.hide_headers_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "passenger_hide_headers_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, hide_headers.elts, hide_headers.nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
peers:
if (conf->upstream.upstream == NULL) {
conf->upstream.upstream = prev->upstream.upstream;
#if NGINX_VERSION_NUM < 7000
conf->upstream.schema = prev->upstream.schema;
#endif
}
if (conf->vars_source == NULL) {
conf->flushes = prev->flushes;
conf->vars_len = prev->vars_len;
conf->vars = prev->vars;
conf->vars_source = prev->vars_source;
if (conf->vars_source == NULL) {
return NGX_CONF_OK;
}
}
conf->vars_len = ngx_array_create(cf->pool, 64, 1);
if (conf->vars_len == NULL) {
return NGX_CONF_ERROR;
}
conf->vars = ngx_array_create(cf->pool, 512, 1);
if (conf->vars == NULL) {
return NGX_CONF_ERROR;
}
src = conf->vars_source->elts;
for (i = 0; i < conf->vars_source->nelts; i++) {
if (ngx_http_script_variables_count(&src[i].value) == 0) {
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len;
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].value.len;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + src[i].value.len
+ sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->vars, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len + src[i].value.len;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
ngx_memcpy(p, src[i].value.data, src[i].value.len);
} else {
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->vars, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
ngx_memcpy(p, src[i].key.data, src[i].key.len);
ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
sc.cf = cf;
sc.source = &src[i].value;
sc.flushes = &conf->flushes;
sc.lengths = &conf->vars_len;
sc.values = &conf->vars;
if (ngx_http_script_compile(&sc) != NGX_OK) {
return NGX_CONF_ERROR;
}
}
code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
code = ngx_array_push_n(conf->vars, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
}
code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
return NGX_CONF_OK;
}
static char *
ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_scgi_loc_conf_t *prev = parent;
ngx_http_scgi_loc_conf_t *conf = child;
u_char *p;
size_t size;
uintptr_t *code;
ngx_uint_t i;
ngx_array_t headers_names;
ngx_keyval_t *src;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
ngx_http_core_loc_conf_t *clcf;
ngx_http_script_compile_t sc;
ngx_http_script_copy_code_t *copy;
if (conf->upstream.store != 0) {
ngx_conf_merge_value(conf->upstream.store, prev->upstream.store, 0);
if (conf->upstream.store_lengths == NULL) {
conf->upstream.store_lengths = prev->upstream.store_lengths;
conf->upstream.store_values = prev->upstream.store_values;
}
}
ngx_conf_merge_uint_value(conf->upstream.store_access,
prev->upstream.store_access, 0600);
ngx_conf_merge_value(conf->upstream.buffering,
prev->upstream.buffering, 1);
ngx_conf_merge_value(conf->upstream.ignore_client_abort,
prev->upstream.ignore_client_abort, 0);
ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
prev->upstream.connect_timeout, 60000);
ngx_conf_merge_msec_value(conf->upstream.send_timeout,
prev->upstream.send_timeout, 60000);
ngx_conf_merge_msec_value(conf->upstream.read_timeout,
prev->upstream.read_timeout, 60000);
ngx_conf_merge_size_value(conf->upstream.send_lowat,
prev->upstream.send_lowat, 0);
ngx_conf_merge_size_value(conf->upstream.buffer_size,
prev->upstream.buffer_size,
(size_t) ngx_pagesize);
ngx_conf_merge_bufs_value(conf->upstream.bufs, prev->upstream.bufs,
8, ngx_pagesize);
if (conf->upstream.bufs.num < 2) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"there must be at least 2 \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
size = conf->upstream.buffer_size;
if (size < conf->upstream.bufs.size) {
size = conf->upstream.bufs.size;
}
ngx_conf_merge_size_value(conf->upstream.busy_buffers_size_conf,
prev->upstream.busy_buffers_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream.busy_buffers_size = 2 * size;
} else {
conf->upstream.busy_buffers_size =
conf->upstream.busy_buffers_size_conf;
}
if (conf->upstream.busy_buffers_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_busy_buffers_size\" must be equal or bigger "
"than maximum of the value of \"scgi_buffer_size\" and "
"one of the \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
if (conf->upstream.busy_buffers_size
> (conf->upstream.bufs.num - 1) * conf->upstream.bufs.size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_busy_buffers_size\" must be less than "
"the size of all \"scgi_buffers\" minus one buffer");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream.temp_file_write_size_conf,
prev->upstream.temp_file_write_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream.temp_file_write_size = 2 * size;
} else {
conf->upstream.temp_file_write_size =
conf->upstream.temp_file_write_size_conf;
}
if (conf->upstream.temp_file_write_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_temp_file_write_size\" must be equal or bigger than "
"maximum of the value of \"scgi_buffer_size\" and "
"one of the \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream.max_temp_file_size_conf,
prev->upstream.max_temp_file_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream.max_temp_file_size = 1024 * 1024 * 1024;
} else {
conf->upstream.max_temp_file_size =
conf->upstream.max_temp_file_size_conf;
}
if (conf->upstream.max_temp_file_size != 0
&& conf->upstream.max_temp_file_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_max_temp_file_size\" must be equal to zero to disable "
"the temporary files usage or must be equal or bigger than "
"maximum of the value of \"scgi_buffer_size\" and "
"one of the \"scgi_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_bitmask_value(conf->upstream.ignore_headers,
prev->upstream.ignore_headers,
NGX_CONF_BITMASK_SET);
ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
prev->upstream.next_upstream,
(NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_ERROR
|NGX_HTTP_UPSTREAM_FT_TIMEOUT));
if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF;
}
if (ngx_conf_merge_path_value(cf, &conf->upstream.temp_path,
prev->upstream.temp_path,
&ngx_http_scgi_temp_path)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
#if (NGX_HTTP_CACHE)
ngx_conf_merge_ptr_value(conf->upstream.cache,
prev->upstream.cache, NULL);
if (conf->upstream.cache && conf->upstream.cache->data == NULL) {
ngx_shm_zone_t *shm_zone;
shm_zone = conf->upstream.cache;
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_cache\" zone \"%V\" is unknown",
&shm_zone->shm.name);
return NGX_CONF_ERROR;
}
ngx_conf_merge_uint_value(conf->upstream.cache_min_uses,
prev->upstream.cache_min_uses, 1);
ngx_conf_merge_bitmask_value(conf->upstream.cache_use_stale,
prev->upstream.cache_use_stale,
(NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF));
if (conf->upstream.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream.cache_use_stale = NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF;
}
if (conf->upstream.cache_methods == 0) {
conf->upstream.cache_methods = prev->upstream.cache_methods;
}
conf->upstream.cache_methods |= NGX_HTTP_GET|NGX_HTTP_HEAD;
ngx_conf_merge_ptr_value(conf->upstream.cache_bypass,
prev->upstream.cache_bypass, NULL);
ngx_conf_merge_ptr_value(conf->upstream.no_cache,
prev->upstream.no_cache, NULL);
ngx_conf_merge_ptr_value(conf->upstream.cache_valid,
prev->upstream.cache_valid, NULL);
if (conf->cache_key.value.data == NULL) {
conf->cache_key = prev->cache_key;
}
#endif
ngx_conf_merge_value(conf->upstream.pass_request_headers,
prev->upstream.pass_request_headers, 1);
ngx_conf_merge_value(conf->upstream.pass_request_body,
prev->upstream.pass_request_body, 1);
ngx_conf_merge_value(conf->upstream.intercept_errors,
prev->upstream.intercept_errors, 0);
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "scgi_hide_headers_hash";
if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream,
&prev->upstream, ngx_http_scgi_hide_headers, &hash)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (conf->upstream.upstream == NULL) {
conf->upstream.upstream = prev->upstream.upstream;
}
if (conf->scgi_lengths == NULL) {
conf->scgi_lengths = prev->scgi_lengths;
conf->scgi_values = prev->scgi_values;
}
if (conf->upstream.upstream || conf->scgi_lengths) {
clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
if (clcf->handler == NULL && clcf->lmt_excpt) {
clcf->handler = ngx_http_scgi_handler;
}
}
if (conf->params_source == NULL) {
conf->flushes = prev->flushes;
conf->params_len = prev->params_len;
conf->params = prev->params;
conf->params_source = prev->params_source;
conf->headers_hash = prev->headers_hash;
#if (NGX_HTTP_CACHE)
if (conf->params_source == NULL) {
if ((conf->upstream.cache == NULL)
== (prev->upstream.cache == NULL))
{
return NGX_CONF_OK;
}
/* 6 is a number of ngx_http_scgi_cache_headers entries */
conf->params_source = ngx_array_create(cf->pool, 6,
sizeof(ngx_keyval_t));
if (conf->params_source == NULL) {
return NGX_CONF_ERROR;
}
}
#else
if (conf->params_source == NULL) {
return NGX_CONF_OK;
}
#endif
}
conf->params_len = ngx_array_create(cf->pool, 64, 1);
if (conf->params_len == NULL) {
return NGX_CONF_ERROR;
}
conf->params = ngx_array_create(cf->pool, 512, 1);
if (conf->params == NULL) {
return NGX_CONF_ERROR;
}
if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
src = conf->params_source->elts;
#if (NGX_HTTP_CACHE)
if (conf->upstream.cache) {
ngx_keyval_t *h, *s;
for (h = ngx_http_scgi_cache_headers; h->key.len; h++) {
for (i = 0; i < conf->params_source->nelts; i++) {
if (ngx_strcasecmp(h->key.data, src[i].key.data) == 0) {
goto next;
}
}
s = ngx_array_push(conf->params_source);
if (s == NULL) {
return NGX_CONF_ERROR;
}
*s = *h;
src = conf->params_source->elts;
next:
h++;
}
}
#endif
for (i = 0; i < conf->params_source->nelts; i++) {
if (src[i].key.len > sizeof("HTTP_") - 1
&& ngx_strncmp(src[i].key.data, "HTTP_", sizeof("HTTP_") - 1) == 0)
{
hk = ngx_array_push(&headers_names);
if (hk == NULL) {
return NGX_CONF_ERROR;
}
hk->key.len = src[i].key.len - 5;
hk->key.data = src[i].key.data + 5;
hk->key_hash = ngx_hash_key_lc(hk->key.data, hk->key.len);
hk->value = (void *) 1;
if (src[i].value.len == 0) {
continue;
}
}
copy = ngx_array_push_n(conf->params_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt) ngx_http_script_copy_len_code;
copy->len = src[i].key.len + 1;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + 1 + sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->params, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len + 1;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
(void) ngx_cpystrn(p, src[i].key.data, src[i].key.len + 1);
ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
sc.cf = cf;
sc.source = &src[i].value;
sc.flushes = &conf->flushes;
sc.lengths = &conf->params_len;
sc.values = &conf->params;
if (ngx_http_script_compile(&sc) != NGX_OK) {
return NGX_CONF_ERROR;
}
code = ngx_array_push_n(conf->params_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
code = ngx_array_push_n(conf->params, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
}
code = ngx_array_push_n(conf->params_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
code = ngx_array_push_n(conf->params, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
conf->header_params = headers_names.nelts;
hash.hash = &conf->headers_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = 64;
hash.name = "scgi_params_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, headers_names.elts, headers_names.nelts) != NGX_OK)
{
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
char *
passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
passenger_loc_conf_t *prev = parent;
passenger_loc_conf_t *conf = child;
ngx_http_core_loc_conf_t *clcf;
size_t size;
ngx_hash_init_t hash;
clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
if (generated_merge_part(conf, prev, cf) == 0) {
return NGX_CONF_ERROR;
}
if (prev->options_cache.data == NULL) {
if (cache_loc_conf_options(cf, prev) != NGX_OK) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"cannot create " PROGRAM_NAME " configuration cache");
return NGX_CONF_ERROR;
}
}
/******************************/
/******************************/
#if (NGX_HTTP_CACHE) && NGINX_VERSION_NUM >= 1007009
if (conf->upstream_config.store > 0) {
conf->upstream_config.cache = 0;
}
if (conf->upstream_config.cache > 0) {
conf->upstream_config.store = 0;
}
#endif
#if NGINX_VERSION_NUM >= 1007009
if (conf->upstream_config.store == NGX_CONF_UNSET) {
ngx_conf_merge_value(conf->upstream_config.store,
prev->upstream_config.store, 0);
conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
conf->upstream_config.store_values = prev->upstream_config.store_values;
}
#else
if (conf->upstream_config.store != 0) {
ngx_conf_merge_value(conf->upstream_config.store,
prev->upstream_config.store, 0);
if (conf->upstream_config.store_lengths == NULL) {
conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
conf->upstream_config.store_values = prev->upstream_config.store_values;
}
}
#endif
ngx_conf_merge_uint_value(conf->upstream_config.store_access,
prev->upstream_config.store_access, 0600);
#if NGINX_VERSION_NUM >= 1007005
ngx_conf_merge_uint_value(conf->upstream_config.next_upstream_tries,
prev->upstream_config.next_upstream_tries, 0);
#endif
ngx_conf_merge_value(conf->upstream_config.buffering,
prev->upstream_config.buffering, 0);
ngx_conf_merge_value(conf->upstream_config.ignore_client_abort,
prev->upstream_config.ignore_client_abort, 0);
#if NGINX_VERSION_NUM >= 1007007
ngx_conf_merge_value(conf->upstream_config.force_ranges,
prev->upstream_config.force_ranges, 0);
#endif
ngx_conf_merge_ptr_value(conf->upstream_config.local,
prev->upstream_config.local, NULL);
ngx_conf_merge_msec_value(conf->upstream_config.connect_timeout,
prev->upstream_config.connect_timeout, 12000000);
ngx_conf_merge_msec_value(conf->upstream_config.send_timeout,
prev->upstream_config.send_timeout, 12000000);
ngx_conf_merge_msec_value(conf->upstream_config.read_timeout,
prev->upstream_config.read_timeout, 12000000);
#if NGINX_VERSION_NUM >= 1007005
ngx_conf_merge_msec_value(conf->upstream_config.next_upstream_timeout,
prev->upstream_config.next_upstream_timeout, 0);
#endif
ngx_conf_merge_size_value(conf->upstream_config.send_lowat,
prev->upstream_config.send_lowat, 0);
ngx_conf_merge_size_value(conf->upstream_config.buffer_size,
prev->upstream_config.buffer_size,
16 * 1024);
#if NGINX_VERSION_NUM >= 1007007
ngx_conf_merge_size_value(conf->upstream_config.limit_rate,
prev->upstream_config.limit_rate, 0);
#endif
ngx_conf_merge_bufs_value(conf->upstream_config.bufs, prev->upstream_config.bufs,
8, 16 * 1024);
if (conf->upstream_config.bufs.num < 2) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"there must be at least 2 \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
size = conf->upstream_config.buffer_size;
if (size < conf->upstream_config.bufs.size) {
size = conf->upstream_config.bufs.size;
}
ngx_conf_merge_size_value(conf->upstream_config.busy_buffers_size_conf,
prev->upstream_config.busy_buffers_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.busy_buffers_size = 2 * size;
} else {
conf->upstream_config.busy_buffers_size =
conf->upstream_config.busy_buffers_size_conf;
}
if (conf->upstream_config.busy_buffers_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_busy_buffers_size\" must be equal to or greater "
"than the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
if (conf->upstream_config.busy_buffers_size
> (conf->upstream_config.bufs.num - 1) * conf->upstream_config.bufs.size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_busy_buffers_size\" must be less than "
"the size of all \"passenger_buffers\" minus one buffer");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream_config.temp_file_write_size_conf,
prev->upstream_config.temp_file_write_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.temp_file_write_size = 2 * size;
} else {
conf->upstream_config.temp_file_write_size =
conf->upstream_config.temp_file_write_size_conf;
}
if (conf->upstream_config.temp_file_write_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_temp_file_write_size\" must be equal to or greater than "
"the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream_config.max_temp_file_size_conf,
prev->upstream_config.max_temp_file_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.max_temp_file_size = 1024 * 1024 * 1024;
} else {
conf->upstream_config.max_temp_file_size =
conf->upstream_config.max_temp_file_size_conf;
}
if (conf->upstream_config.max_temp_file_size != 0
&& conf->upstream_config.max_temp_file_size < size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_max_temp_file_size\" must be equal to zero to disable "
"temporary files usage or must be equal to or greater than "
"the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_bitmask_value(conf->upstream_config.ignore_headers,
prev->upstream_config.ignore_headers,
NGX_CONF_BITMASK_SET);
ngx_conf_merge_bitmask_value(conf->upstream_config.next_upstream,
prev->upstream_config.next_upstream,
(NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_ERROR
|NGX_HTTP_UPSTREAM_FT_TIMEOUT));
if (conf->upstream_config.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream_config.next_upstream = NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF;
}
ngx_conf_merge_path_value(cf,
&conf->upstream_config.temp_path,
prev->upstream_config.temp_path,
&ngx_http_proxy_temp_path);
#if (NGX_HTTP_CACHE)
#if NGINX_VERSION_NUM >= 1007009
if (conf->upstream_config.cache == NGX_CONF_UNSET) {
ngx_conf_merge_value(conf->upstream_config.cache,
prev->upstream_config.cache, 0);
conf->upstream_config.cache_zone = prev->upstream_config.cache_zone;
conf->upstream_config.cache_value = prev->upstream_config.cache_value;
}
if (conf->upstream_config.cache_zone && conf->upstream_config.cache_zone->data == NULL) {
ngx_shm_zone_t *shm_zone;
shm_zone = conf->upstream_config.cache_zone;
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_cache\" zone \"%V\" is unknown",
&shm_zone->shm.name);
return NGX_CONF_ERROR;
}
#else
ngx_conf_merge_ptr_value(conf->upstream_config.cache,
prev->upstream_config.cache, NULL);
if (conf->upstream_config.cache && conf->upstream_config.cache->data == NULL) {
ngx_shm_zone_t *shm_zone;
shm_zone = conf->upstream_config.cache;
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_cache\" zone \"%V\" is unknown",
&shm_zone->shm.name);
return NGX_CONF_ERROR;
}
#endif
ngx_conf_merge_uint_value(conf->upstream_config.cache_min_uses,
prev->upstream_config.cache_min_uses, 1);
ngx_conf_merge_bitmask_value(conf->upstream_config.cache_use_stale,
prev->upstream_config.cache_use_stale,
(NGX_CONF_BITMASK_SET
| NGX_HTTP_UPSTREAM_FT_OFF));
if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream_config.cache_use_stale = NGX_CONF_BITMASK_SET
| NGX_HTTP_UPSTREAM_FT_OFF;
}
if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
conf->upstream_config.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
}
if (conf->upstream_config.cache_methods == 0) {
conf->upstream_config.cache_methods = prev->upstream_config.cache_methods;
}
conf->upstream_config.cache_methods |= NGX_HTTP_GET | NGX_HTTP_HEAD;
ngx_conf_merge_ptr_value(conf->upstream_config.cache_bypass,
prev->upstream_config.cache_bypass, NULL);
ngx_conf_merge_ptr_value(conf->upstream_config.no_cache,
prev->upstream_config.no_cache, NULL);
ngx_conf_merge_ptr_value(conf->upstream_config.cache_valid,
prev->upstream_config.cache_valid, NULL);
if (conf->cache_key.value.data == NULL) {
conf->cache_key = prev->cache_key;
}
ngx_conf_merge_value(conf->upstream_config.cache_lock,
prev->upstream_config.cache_lock, 0);
ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_timeout,
prev->upstream_config.cache_lock_timeout, 5000);
ngx_conf_merge_value(conf->upstream_config.cache_revalidate,
prev->upstream_config.cache_revalidate, 0);
#if NGINX_VERSION_NUM >= 1007008
ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_age,
prev->upstream_config.cache_lock_age, 5000);
#endif
#if NGINX_VERSION_NUM >= 1006000
ngx_conf_merge_value(conf->upstream_config.cache_revalidate,
prev->upstream_config.cache_revalidate, 0);
#endif
#endif
ngx_conf_merge_value(conf->upstream_config.pass_request_headers,
prev->upstream_config.pass_request_headers, 1);
ngx_conf_merge_value(conf->upstream_config.pass_request_body,
prev->upstream_config.pass_request_body, 1);
ngx_conf_merge_value(conf->upstream_config.intercept_errors,
prev->upstream_config.intercept_errors, 0);
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "passenger_hide_headers_hash";
if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream_config,
&prev->upstream_config, headers_to_hide, &hash)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (conf->upstream_config.upstream == NULL) {
conf->upstream_config.upstream = prev->upstream_config.upstream;
}
if (conf->enabled == 1 /* and not NGX_CONF_UNSET */
&& passenger_main_conf.root_dir.len != 0
&& clcf->handler == NULL /* no handler set by other modules */)
{
clcf->handler = passenger_content_handler;
}
conf->headers_hash_bucket_size = ngx_align(conf->headers_hash_bucket_size,
ngx_cacheline_size);
hash.max_size = conf->headers_hash_max_size;
hash.bucket_size = conf->headers_hash_bucket_size;
hash.name = "passenger_headers_hash";
if (merge_headers(cf, conf, prev) != NGX_OK) {
return NGX_CONF_ERROR;
}
if (cache_loc_conf_options(cf, conf) != NGX_OK) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"cannot create " PROGRAM_NAME " configuration cache");
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
