static char *
ngx_stream_proxy_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_stream_proxy_srv_conf_t *prev = parent;
ngx_stream_proxy_srv_conf_t *conf = child;
ngx_conf_merge_msec_value(conf->connect_timeout,
prev->connect_timeout, 60000);
ngx_conf_merge_msec_value(conf->timeout,
prev->timeout, 10 * 60000);
ngx_conf_merge_msec_value(conf->next_upstream_timeout,
prev->next_upstream_timeout, 0);
ngx_conf_merge_size_value(conf->buffer_size,
prev->buffer_size, 16384);
ngx_conf_merge_size_value(conf->upload_rate,
prev->upload_rate, 0);
ngx_conf_merge_size_value(conf->download_rate,
prev->download_rate, 0);
ngx_conf_merge_uint_value(conf->next_upstream_tries,
prev->next_upstream_tries, 0);
ngx_conf_merge_value(conf->next_upstream, prev->next_upstream, 1);
ngx_conf_merge_value(conf->proxy_protocol, prev->proxy_protocol, 0);
ngx_conf_merge_ptr_value(conf->local, prev->local, NULL);
#if (NGX_STREAM_SSL)
ngx_conf_merge_value(conf->ssl_enable, prev->ssl_enable, 0);
ngx_conf_merge_value(conf->ssl_session_reuse, prev->ssl_session_reuse, 1);
ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
(NGX_CONF_BITMASK_SET|NGX_SSL_TLSv1
|NGX_SSL_TLSv1_1|NGX_SSL_TLSv1_2));
ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers, "DEFAULT");
ngx_conf_merge_str_value(conf->ssl_name, prev->ssl_name, "");
ngx_conf_merge_value(conf->ssl_server_name, prev->ssl_server_name, 0);
ngx_conf_merge_value(conf->ssl_verify, prev->ssl_verify, 0);
ngx_conf_merge_uint_value(conf->ssl_verify_depth,
prev->ssl_verify_depth, 1);
ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
prev->ssl_trusted_certificate, "");
ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");
ngx_conf_merge_str_value(conf->ssl_certificate,
prev->ssl_certificate, "");
ngx_conf_merge_str_value(conf->ssl_certificate_key,
prev->ssl_certificate_key, "");
ngx_conf_merge_ptr_value(conf->ssl_passwords, prev->ssl_passwords, NULL);
if (conf->ssl_enable && ngx_stream_proxy_set_ssl(cf, conf) != NGX_OK) {
return NGX_CONF_ERROR;
}
#endif
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, 600000);
ngx_conf_merge_msec_value(conf->upstream.send_timeout,
prev->upstream.send_timeout, 600000);
ngx_conf_merge_msec_value(conf->upstream.read_timeout,
prev->upstream.read_timeout, 600000);
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_lua_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_lua_loc_conf_t *prev = parent;
ngx_http_lua_loc_conf_t *conf = child;
if (conf->rewrite_src.value.len == 0) {
conf->rewrite_src = prev->rewrite_src;
conf->rewrite_handler = prev->rewrite_handler;
conf->rewrite_src_key = prev->rewrite_src_key;
}
if (conf->access_src.value.len == 0) {
conf->access_src = prev->access_src;
conf->access_handler = prev->access_handler;
conf->access_src_key = prev->access_src_key;
}
if (conf->content_src.value.len == 0) {
conf->content_src = prev->content_src;
conf->content_handler = prev->content_handler;
conf->content_src_key = prev->content_src_key;
}
if (conf->log_src.value.len == 0) {
conf->log_src = prev->log_src;
conf->log_handler = prev->log_handler;
conf->log_src_key = prev->log_src_key;
}
if (conf->header_filter_src.value.len == 0) {
conf->header_filter_src = prev->header_filter_src;
conf->header_filter_handler = prev->header_filter_handler;
conf->header_filter_src_key = prev->header_filter_src_key;
}
if (conf->body_filter_src.value.len == 0) {
conf->body_filter_src = prev->body_filter_src;
conf->body_filter_handler = prev->body_filter_handler;
conf->body_filter_src_key = prev->body_filter_src_key;
}
ngx_conf_merge_value(conf->force_read_body, prev->force_read_body, 0);
ngx_conf_merge_value(conf->enable_code_cache, prev->enable_code_cache, 1);
ngx_conf_merge_value(conf->http10_buffering, prev->http10_buffering, 1);
ngx_conf_merge_value(conf->check_client_abort, prev->check_client_abort, 0);
ngx_conf_merge_msec_value(conf->keepalive_timeout,
prev->keepalive_timeout, 60000);
ngx_conf_merge_msec_value(conf->connect_timeout,
prev->connect_timeout, 60000);
ngx_conf_merge_msec_value(conf->send_timeout,
prev->send_timeout, 60000);
ngx_conf_merge_msec_value(conf->read_timeout,
prev->read_timeout, 60000);
ngx_conf_merge_size_value(conf->send_lowat,
prev->send_lowat, 0);
ngx_conf_merge_size_value(conf->buffer_size,
prev->buffer_size,
(size_t) ngx_pagesize);
ngx_conf_merge_uint_value(conf->pool_size, prev->pool_size, 30);
ngx_conf_merge_value(conf->transform_underscores_in_resp_headers,
prev->transform_underscores_in_resp_headers, 1);
ngx_conf_merge_value(conf->log_socket_errors, prev->log_socket_errors, 1);
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;
}
static char *
ngx_http_lua_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_lua_loc_conf_t *prev = parent;
ngx_http_lua_loc_conf_t *conf = child;
if (conf->rewrite_src.value.len == 0) {
conf->rewrite_src = prev->rewrite_src;
conf->rewrite_handler = prev->rewrite_handler;
conf->rewrite_src_key = prev->rewrite_src_key;
conf->rewrite_chunkname = prev->rewrite_chunkname;
}
if (conf->access_src.value.len == 0) {
conf->access_src = prev->access_src;
conf->access_handler = prev->access_handler;
conf->access_src_key = prev->access_src_key;
conf->access_chunkname = prev->access_chunkname;
}
if (conf->content_src.value.len == 0) {
conf->content_src = prev->content_src;
conf->content_handler = prev->content_handler;
conf->content_src_key = prev->content_src_key;
conf->content_chunkname = prev->content_chunkname;
}
if (conf->log_src.value.len == 0) {
conf->log_src = prev->log_src;
conf->log_handler = prev->log_handler;
conf->log_src_key = prev->log_src_key;
conf->log_chunkname = prev->log_chunkname;
}
if (conf->header_filter_src.value.len == 0) {
conf->header_filter_src = prev->header_filter_src;
conf->header_filter_handler = prev->header_filter_handler;
conf->header_filter_src_key = prev->header_filter_src_key;
}
if (conf->body_filter_src.value.len == 0) {
conf->body_filter_src = prev->body_filter_src;
conf->body_filter_handler = prev->body_filter_handler;
conf->body_filter_src_key = prev->body_filter_src_key;
}
#if (NGX_HTTP_SSL)
# if defined(nginx_version) && nginx_version >= 1001013
ngx_conf_merge_bitmask_value(conf->ssl_protocols, prev->ssl_protocols,
(NGX_CONF_BITMASK_SET|NGX_SSL_SSLv3
|NGX_SSL_TLSv1|NGX_SSL_TLSv1_1
|NGX_SSL_TLSv1_2));
# endif
ngx_conf_merge_str_value(conf->ssl_ciphers, prev->ssl_ciphers,
"DEFAULT");
ngx_conf_merge_uint_value(conf->ssl_verify_depth,
prev->ssl_verify_depth, 1);
ngx_conf_merge_str_value(conf->ssl_trusted_certificate,
prev->ssl_trusted_certificate, "");
ngx_conf_merge_str_value(conf->ssl_crl, prev->ssl_crl, "");
if (ngx_http_lua_set_ssl(cf, conf) != NGX_OK) {
return NGX_CONF_ERROR;
}
#endif
ngx_conf_merge_value(conf->force_read_body, prev->force_read_body, 0);
ngx_conf_merge_value(conf->enable_code_cache, prev->enable_code_cache, 1);
ngx_conf_merge_value(conf->http10_buffering, prev->http10_buffering, 1);
ngx_conf_merge_value(conf->check_client_abort, prev->check_client_abort, 0);
ngx_conf_merge_value(conf->use_default_type, prev->use_default_type, 1);
ngx_conf_merge_msec_value(conf->keepalive_timeout,
prev->keepalive_timeout, 60000);
ngx_conf_merge_msec_value(conf->connect_timeout,
prev->connect_timeout, 60000);
ngx_conf_merge_msec_value(conf->send_timeout,
prev->send_timeout, 60000);
ngx_conf_merge_msec_value(conf->read_timeout,
prev->read_timeout, 60000);
ngx_conf_merge_size_value(conf->send_lowat,
prev->send_lowat, 0);
ngx_conf_merge_size_value(conf->buffer_size,
prev->buffer_size,
(size_t) ngx_pagesize);
ngx_conf_merge_uint_value(conf->pool_size, prev->pool_size, 30);
ngx_conf_merge_value(conf->transform_underscores_in_resp_headers,
prev->transform_underscores_in_resp_headers, 1);
ngx_conf_merge_value(conf->log_socket_errors, prev->log_socket_errors, 1);
return NGX_CONF_OK;
}
static char *
ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_ssl_srv_conf_t *prev = parent;
ngx_http_ssl_srv_conf_t *conf = child;
ngx_pool_cleanup_t *cln;
if (conf->enable == NGX_CONF_UNSET) {
if (prev->enable == NGX_CONF_UNSET) {
conf->enable = 0;
} else {
conf->enable = prev->enable;
conf->file = prev->file;
conf->line = prev->line;
}
}
ngx_conf_merge_value(conf->session_timeout,
prev->session_timeout, 300);
ngx_conf_merge_value(conf->prefer_server_ciphers,
prev->prefer_server_ciphers, 0);
ngx_conf_merge_bitmask_value(conf->protocols, prev->protocols,
(NGX_CONF_BITMASK_SET|NGX_SSL_TLSv1
|NGX_SSL_TLSv1_1|NGX_SSL_TLSv1_2));
ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
NGX_SSL_BUFSIZE);
ngx_conf_merge_uint_value(conf->verify, prev->verify, 0);
ngx_conf_merge_uint_value(conf->verify_depth, prev->verify_depth, 1);
ngx_conf_merge_ptr_value(conf->certificates, prev->certificates, NULL);
ngx_conf_merge_ptr_value(conf->certificate_keys, prev->certificate_keys,
NULL);
ngx_conf_merge_ptr_value(conf->passwords, prev->passwords, NULL);
ngx_conf_merge_str_value(conf->dhparam, prev->dhparam, "");
ngx_conf_merge_str_value(conf->client_certificate, prev->client_certificate,
"");
ngx_conf_merge_str_value(conf->trusted_certificate,
prev->trusted_certificate, "");
ngx_conf_merge_str_value(conf->crl, prev->crl, "");
ngx_conf_merge_str_value(conf->ecdh_curve, prev->ecdh_curve,
NGX_DEFAULT_ECDH_CURVE);
ngx_conf_merge_str_value(conf->ciphers, prev->ciphers, NGX_DEFAULT_CIPHERS);
ngx_conf_merge_value(conf->stapling, prev->stapling, 0);
ngx_conf_merge_value(conf->stapling_verify, prev->stapling_verify, 0);
ngx_conf_merge_str_value(conf->stapling_file, prev->stapling_file, "");
ngx_conf_merge_str_value(conf->stapling_responder,
prev->stapling_responder, "");
conf->ssl.log = cf->log;
if (conf->enable) {
if (conf->certificates == NULL) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"no \"ssl_certificate\" is defined for "
"the \"ssl\" directive in %s:%ui",
conf->file, conf->line);
return NGX_CONF_ERROR;
}
if (conf->certificate_keys == NULL) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"no \"ssl_certificate_key\" is defined for "
"the \"ssl\" directive in %s:%ui",
conf->file, conf->line);
return NGX_CONF_ERROR;
}
if (conf->certificate_keys->nelts < conf->certificates->nelts) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"no \"ssl_certificate_key\" is defined "
"for certificate \"%V\" and "
"the \"ssl\" directive in %s:%ui",
((ngx_str_t *) conf->certificates->elts)
+ conf->certificates->nelts - 1,
conf->file, conf->line);
return NGX_CONF_ERROR;
}
} else {
if (conf->certificates == NULL) {
return NGX_CONF_OK;
}
if (conf->certificate_keys == NULL
|| conf->certificate_keys->nelts < conf->certificates->nelts)
{
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"no \"ssl_certificate_key\" is defined "
"for certificate \"%V\"",
((ngx_str_t *) conf->certificates->elts)
+ conf->certificates->nelts - 1);
return NGX_CONF_ERROR;
}
}
if (ngx_ssl_create(&conf->ssl, conf->protocols, conf) != NGX_OK) {
return NGX_CONF_ERROR;
}
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
if (SSL_CTX_set_tlsext_servername_callback(conf->ssl.ctx,
ngx_http_ssl_servername)
== 0)
{
ngx_log_error(NGX_LOG_WARN, cf->log, 0,
"nginx was built with SNI support, however, now it is linked "
"dynamically to an OpenSSL library which has no tlsext support, "
"therefore SNI is not available");
}
#endif
#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
SSL_CTX_set_alpn_select_cb(conf->ssl.ctx, ngx_http_ssl_alpn_select, NULL);
#endif
#ifdef TLSEXT_TYPE_next_proto_neg
SSL_CTX_set_next_protos_advertised_cb(conf->ssl.ctx,
ngx_http_ssl_npn_advertised, NULL);
#endif
cln = ngx_pool_cleanup_add(cf->pool, 0);
if (cln == NULL) {
return NGX_CONF_ERROR;
}
cln->handler = ngx_ssl_cleanup_ctx;
cln->data = &conf->ssl;
if (ngx_ssl_certificates(cf, &conf->ssl, conf->certificates,
conf->certificate_keys, conf->passwords)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (ngx_ssl_ciphers(cf, &conf->ssl, &conf->ciphers,
conf->prefer_server_ciphers)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
conf->ssl.buffer_size = conf->buffer_size;
if (conf->verify) {
if (conf->client_certificate.len == 0 && conf->verify != 3) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"no ssl_client_certificate for ssl_client_verify");
return NGX_CONF_ERROR;
}
if (ngx_ssl_client_certificate(cf, &conf->ssl,
&conf->client_certificate,
conf->verify_depth)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
}
if (ngx_ssl_trusted_certificate(cf, &conf->ssl,
&conf->trusted_certificate,
conf->verify_depth)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (ngx_ssl_crl(cf, &conf->ssl, &conf->crl) != NGX_OK) {
return NGX_CONF_ERROR;
}
if (ngx_ssl_dhparam(cf, &conf->ssl, &conf->dhparam) != NGX_OK) {
return NGX_CONF_ERROR;
}
if (ngx_ssl_ecdh_curve(cf, &conf->ssl, &conf->ecdh_curve) != NGX_OK) {
return NGX_CONF_ERROR;
}
ngx_conf_merge_value(conf->builtin_session_cache,
prev->builtin_session_cache, NGX_SSL_NONE_SCACHE);
if (conf->shm_zone == NULL) {
conf->shm_zone = prev->shm_zone;
}
if (ngx_ssl_session_cache(&conf->ssl, &ngx_http_ssl_sess_id_ctx,
conf->builtin_session_cache,
conf->shm_zone, conf->session_timeout)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
ngx_conf_merge_value(conf->session_tickets, prev->session_tickets, 1);
#ifdef SSL_OP_NO_TICKET
if (!conf->session_tickets) {
SSL_CTX_set_options(conf->ssl.ctx, SSL_OP_NO_TICKET);
}
#endif
ngx_conf_merge_ptr_value(conf->session_ticket_keys,
prev->session_ticket_keys, NULL);
if (ngx_ssl_session_ticket_keys(cf, &conf->ssl, conf->session_ticket_keys)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (conf->stapling) {
if (ngx_ssl_stapling(cf, &conf->ssl, &conf->stapling_file,
&conf->stapling_responder, conf->stapling_verify)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
}
return NGX_CONF_OK;
}
static char *
ngx_mail_imap_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_mail_imap_srv_conf_t *prev = parent;
ngx_mail_imap_srv_conf_t *conf = child;
u_char *p, *p1, *p2, *p3;
size_t size, s1, s2, s3;
ngx_str_t *c, *d;
ngx_uint_t i;
ngx_conf_merge_size_value(conf->client_buffer_size,
prev->client_buffer_size,
(size_t) 4 * ngx_pagesize);
ngx_conf_merge_bitmask_value(conf->auth_methods,
prev->auth_methods,
(NGX_CONF_BITMASK_SET
|NGX_MAIL_AUTH_PLAIN_ENABLED));
if (conf->id_params.nelts == 0) {
conf->id_params = prev->id_params;
}
if (conf->capabilities.nelts == 0) {
conf->capabilities = prev->capabilities;
}
if (conf->capabilities.nelts == 0) {
for (d = ngx_mail_imap_default_capabilities; d->len; d++) {
c = ngx_array_push(&conf->capabilities);
if (c == NULL) {
return NGX_CONF_ERROR;
}
*c = *d;
}
}
s1 = sizeof("* CAPABILITY" CRLF) - 1;
s2 = s1;
s3 = s1;
c = conf->capabilities.elts;
for (i = 0; i < conf->capabilities.nelts; i++) {
s1 += 1 + c[i].len;
s2 += 1 + c[i].len;
s3 += 1 + c[i].len;
}
if (conf->auth_methods & NGX_MAIL_AUTH_LOGIN_ENABLED) {
s1 += sizeof (" AUTH=LOGIN") - 1;
s2 += sizeof (" AUTH=LOGIN") - 1;
}
if (conf->auth_methods & NGX_MAIL_AUTH_PLAIN_ENABLED) {
s1 += sizeof (" AUTH=PLAIN") - 1;
s2 += sizeof (" AUTH=PLAIN") - 1;
}
if (conf->auth_methods & NGX_MAIL_AUTH_CRAM_MD5_ENABLED) {
s1 += sizeof (" AUTH=CRAM-MD5") - 1;
s2 += sizeof (" AUTH=CRAM-MD5") - 1;
}
if (conf->auth_methods & NGX_MAIL_AUTH_GSSAPI_ENABLED) {
s1 += sizeof (" AUTH=GSSAPI") - 1;
s2 += sizeof (" AUTH=GSSAPI") - 1;
s3 += sizeof (" AUTH=GSSAPI") - 1;
}
s2 += sizeof (" STARTTLS") - 1;
s3 += sizeof (" STARTTLS") - 1;
s3 += sizeof (" LOGINDISABLED") - 1;
p1 = ngx_palloc(cf->pool, s1);
if (p1 == NULL) {
return NGX_CONF_ERROR;
}
p2 = ngx_palloc(cf->pool, s2);
if (p2 == NULL) {
return NGX_CONF_ERROR;
}
p3 = ngx_palloc(cf->pool, s3);
if (p3 == NULL) {
return NGX_CONF_ERROR;
}
conf->capability.len = s1;
conf->capability.data = p1;
conf->starttls_capability.len = s2;
conf->starttls_capability.data = p2;
conf->starttls_only_capability.len = s3;
conf->starttls_only_capability.data = p3;
p1 = ngx_cpymem(p1, "* CAPABILITY", sizeof("* CAPABILITY") - 1);
p2 = ngx_cpymem(p2, "* CAPABILITY", sizeof("* CAPABILITY") - 1);
p3 = ngx_cpymem(p3, "* CAPABILITY", sizeof("* CAPABILITY") - 1);
c = conf->capabilities.elts;
for (i = 0; i < conf->capabilities.nelts; i++) {
*p1++ = ' ';
p1 = ngx_cpymem(p1,c[i].data,c[i].len);
*p2++ = ' ';
p2 = ngx_cpymem(p2,c[i].data,c[i].len);
*p3++ = ' ';
p3 = ngx_cpymem(p3,c[i].data,c[i].len);
}
if (conf->auth_methods & NGX_MAIL_AUTH_LOGIN_ENABLED) {
p1 = ngx_cpymem(p1," AUTH=LOGIN", sizeof(" AUTH=LOGIN") - 1);
p2 = ngx_cpymem(p2," AUTH=LOGIN", sizeof(" AUTH=LOGIN") - 1);
}
if (conf->auth_methods & NGX_MAIL_AUTH_PLAIN_ENABLED) {
p1 = ngx_cpymem(p1," AUTH=PLAIN", sizeof(" AUTH=PLAIN") - 1);
p2 = ngx_cpymem(p2," AUTH=PLAIN", sizeof(" AUTH=PLAIN") - 1);
}
if (conf->auth_methods & NGX_MAIL_AUTH_CRAM_MD5_ENABLED) {
p1 = ngx_cpymem(p1," AUTH=CRAM-MD5", sizeof(" AUTH=CRAM-MD5") - 1);
p2 = ngx_cpymem(p2," AUTH=CRAM-MD5", sizeof(" AUTH=CRAM-MD5") - 1);
}
if (conf->auth_methods & NGX_MAIL_AUTH_GSSAPI_ENABLED) {
p1 = ngx_cpymem(p1," AUTH=GSSAPI", sizeof(" AUTH=GSSAPI") - 1);
p2 = ngx_cpymem(p2," AUTH=GSSAPI", sizeof(" AUTH=GSSAPI") - 1);
p3 = ngx_cpymem(p3," AUTH=GSSAPI", sizeof(" AUTH=GSSAPI") - 1);
}
p2 = ngx_cpymem(p2," STARTTLS",sizeof(" STARTTLS")-1);
p3 = ngx_cpymem(p3," STARTTLS",sizeof(" STARTTLS")-1);
p3 = ngx_cpymem(p3," LOGINDISABLED",sizeof(" LOGINDISABLED")-1);
*p1++ = CR; *p1++ = LF;
*p2++ = CR; *p2++ = LF;
*p3++ = CR; *p3++ = LF;
ngx_conf_merge_str_value(conf->greeting, prev->greeting, "");
if (conf->greeting.len == 0) {
conf->greeting = default_imap_greeting;
}
p = ngx_pnalloc(cf->pool, conf->greeting.len + 2);
if (p == NULL) {
return NGX_CONF_ERROR;
}
ngx_memcpy(p, conf->greeting.data, conf->greeting.len);
ngx_memcpy(p + conf->greeting.len, CRLF, sizeof(CRLF)-1);
conf->greeting.data = p;
conf->greeting.len += 2;
size = sizeof ("* ID ()" CRLF) - 1;
c = conf->id_params.elts;
for (i = 0; i < conf->id_params.nelts; ++i) {
if (!((c[i].len == 3) &&
(c[i].data[0] == 'n' || c[i].data[0] == 'N') &&
(c[i].data[1] == 'i' || c[i].data[1] == 'I') &&
(c[i].data[2] == 'l' || c[i].data[2] == 'L'))
)
{
size += 2; // for enclosing quotes
}
size += c[i].len;
size += 1; // for following SP
}
if (conf->id_params.nelts > 0) {
--size; // no SP follows the last parameter
} else {
size = size - 2 + 3; // take away the () and put nil
}
p = ngx_pnalloc(cf->pool, size);
if (p == NULL) {
return NGX_CONF_ERROR;
}
conf->id.len = size;
conf->id.data = p;
p = ngx_cpymem (p, "* ID ", sizeof ("* ID ") -1);
if (conf->id_params.nelts > 0)
{
*p++ = '(';
for (i = 0; i < conf->id_params.nelts; ++i)
{
if (!((c[i].len == 3) &&
(c[i].data[0] == 'n' || c[i].data[0] == 'N') &&
(c[i].data[1] == 'i' || c[i].data[1] == 'I') &&
(c[i].data[2] == 'l' || c[i].data[2] == 'L'))
)
{
*p++ = '"';
p = ngx_cpymem(p, c[i].data, c[i].len);
*p++ = '"';
}
else
{
p = ngx_cpymem(p, c[i].data, c[i].len);
}
if (i < conf->id_params.nelts - 1)
*p++ = ' ';
}
*p++ = ')';
}
else
{
p = ngx_cpymem (p, "nil", sizeof("nil") - 1);
}
*p++ = CR; *p = LF;
ngx_conf_merge_value (conf->literalauth, prev->literalauth,1);
return NGX_CONF_OK;
}
static char *
ngx_http_srcache_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_srcache_loc_conf_t *prev = parent;
ngx_http_srcache_loc_conf_t *conf = child;
ngx_hash_init_t hash;
ngx_conf_merge_ptr_value(conf->fetch, prev->fetch, NULL);
ngx_conf_merge_ptr_value(conf->store, prev->store, NULL);
ngx_conf_merge_size_value(conf->buf_size, prev->buf_size,
(size_t) ngx_pagesize);
ngx_conf_merge_size_value(conf->store_max_size, prev->store_max_size, 0);
ngx_conf_merge_size_value(conf->header_buf_size, prev->header_buf_size,
(size_t) ngx_pagesize);
if (conf->fetch_skip == NULL) {
conf->fetch_skip = prev->fetch_skip;
}
if (conf->store_skip == NULL) {
conf->store_skip = prev->store_skip;
}
if (conf->store_statuses == NULL) {
conf->store_statuses = prev->store_statuses;
}
if (conf->cache_methods == 0) {
conf->cache_methods = prev->cache_methods;
}
conf->cache_methods |= NGX_HTTP_GET|NGX_HTTP_HEAD;
ngx_conf_merge_value(conf->req_cache_control, prev->req_cache_control, 0);
ngx_conf_merge_value(conf->resp_cache_control, prev->resp_cache_control, 1);
ngx_conf_merge_value(conf->store_private, prev->store_private, 0);
ngx_conf_merge_value(conf->store_no_store, prev->store_no_store, 0);
ngx_conf_merge_value(conf->store_no_cache, prev->store_no_cache, 0);
ngx_conf_merge_value(conf->store_ranges, prev->store_ranges, 0);
ngx_conf_merge_value(conf->max_expire, prev->max_expire, 0);
ngx_conf_merge_value(conf->default_expire, prev->default_expire, 60);
ngx_conf_merge_value(conf->ignore_content_encoding,
prev->ignore_content_encoding, 0);
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "srcache_store_hide_headers_hash";
if (ngx_http_srcache_hide_headers_hash(cf, conf,
prev, ngx_http_srcache_hide_headers, &hash)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
