char *
ngx_http_merge_types(ngx_conf_t *cf, ngx_array_t *keys, ngx_hash_t *types_hash,
ngx_array_t *prev_keys, ngx_hash_t *prev_types_hash,
ngx_str_t *default_types)
{
ngx_hash_init_t hash;
if (keys) {
hash.hash = types_hash;
hash.key = NULL;
hash.max_size = 2048;
hash.bucket_size = 64;
hash.name = "test_types_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, keys->elts, keys->nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
if (prev_types_hash->buckets == NULL) {
if (prev_keys == NULL) {
if (ngx_http_set_default_types(cf, &prev_keys, default_types)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
}
hash.hash = prev_types_hash;
hash.key = NULL;
hash.max_size = 2048;
hash.bucket_size = 64;
hash.name = "test_types_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, prev_keys->elts, prev_keys->nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
}
*types_hash = *prev_types_hash;
return NGX_CONF_OK;
}
ngx_int_t
ngx_http_secure_token_init_processors_hash(ngx_conf_t *cf, ngx_http_secure_token_loc_conf_t* conf)
{
ngx_hash_key_t hash_keys[sizeof(body_processors) / sizeof(body_processors[0])];
ngx_hash_init_t hash;
ngx_str_t* content_type;
ngx_int_t rc;
unsigned i;
for (i = 0; i < sizeof(hash_keys) / sizeof(hash_keys[0]); i++)
{
content_type = (ngx_str_t*)((u_char*)conf + body_processors[i].content_type_offset);
hash_keys[i].key = *content_type;
hash_keys[i].key_hash = ngx_hash_key_lc(content_type->data, content_type->len);
hash_keys[i].value = &body_processors[i];
}
hash.hash = &conf->processors_hash;
hash.key = ngx_hash_key;
hash.max_size = 512;
hash.bucket_size = 64;
hash.name = "processors_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
rc = ngx_hash_init(&hash, hash_keys, sizeof(hash_keys) / sizeof(hash_keys[0]));
if (rc != NGX_OK)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "ngx_hash_init failed %i", rc);
return rc;
}
return NGX_OK;
}
static char *ngx_http_small_light_pattern_define(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_small_light_conf_t *srv_conf;
ngx_uint_t rc;
ngx_str_t *ptn_name;
ngx_str_t *ptn_str;
ngx_str_t *value;
ngx_hash_init_t hash;
srv_conf = conf;
value = cf->args->elts;
ptn_name = &value[1];
ptn_str = &value[2];
rc = ngx_hash_add_key(&srv_conf->patterns, ptn_name, ptn_str->data, NGX_HASH_READONLY_KEY);
if (rc != NGX_OK) {
return NGX_CONF_ERROR;
}
hash.hash = &srv_conf->hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 128;
hash.bucket_size = ngx_cacheline_size;
hash.name = "small_light_pattern_define";
hash.pool = srv_conf->patterns.keys.pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, srv_conf->patterns.keys.elts, srv_conf->patterns.keys.nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
int main()
{
ngx_uint_t k; //, p, h;
ngx_pool_t* pool;
ngx_hash_init_t hash_init;
ngx_hash_t* hash;
ngx_array_t* elements;
ngx_hash_key_t* arr_node;
char* find;
int i;
ngx_log_t *log;
log = (ngx_log_t *)malloc(sizeof(ngx_log_t));
log->log_level = 0;
ngx_cacheline_size = 32;
/* hash key cal start */
ngx_str_t str = ngx_string("hello, world");
k = ngx_hash_key_lc(str.data, str.len);
pool = ngx_create_pool(1024*10, log);
printf("caculated key is %u\n", k);
/* hask key cal end */
hash = (ngx_hash_t *)ngx_pcalloc(pool, sizeof(hash));
hash_init.hash = hash; // hash结构
hash_init.key = &ngx_hash_key_lc; // hash算法函数
hash_init.max_size = 1024 * 10; // max_size
hash_init.bucket_size = 64; // ngx_align(64, ngx_cacheline_size);
hash_init.name = "yahoo_guy_hash"; // 在log里会用到
hash_init.pool = pool; // 内存池
hash_init.temp_pool = NULL;
/* 创建数组 */
elements = ngx_array_create(pool, 32, sizeof(ngx_hash_key_t));
for(i = 0; i < 3; i++) {
arr_node = (ngx_hash_key_t *)ngx_array_push(elements);
arr_node->key = (names[i]);
arr_node->key_hash = ngx_hash_key_lc(arr_node->key.data, arr_node->key.len);
arr_node->value = (void*)descs[i];
printf("key: %s, key_hash: %u\n", arr_node->key.data, arr_node->key_hash);
}
if (ngx_hash_init(&hash_init, (ngx_hash_key_t*)elements->elts, elements->nelts) != NGX_OK) {
return 1;
}
/* 查找 */
k = ngx_hash_key_lc(names[0].data, names[0].len);
printf("%s key is %d\n", names[0].data, k);
find = (char *)ngx_hash_find(hash, k, (u_char*)names[0].data, names[0].len);
if (find) {
printf("get desc of rainx: %s\n", (char *)find);
}
ngx_array_destroy(elements);
ngx_destroy_pool(pool);
return 0;
}
static ngx_int_t
ngx_http_vod_init_hash(
ngx_conf_t *cf,
ngx_http_vod_uri_param_def_t* elements,
ngx_http_vod_loc_conf_t* conf,
char* hash_name,
ngx_hash_t* output)
{
ngx_http_vod_uri_param_def_t *element;
ngx_array_t elements_arr;
ngx_hash_key_t *hash_key;
ngx_hash_init_t hash;
ngx_str_t* cur_key;
if (ngx_array_init(&elements_arr, cf->temp_pool, 32, sizeof(ngx_hash_key_t)) != NGX_OK)
{
return NGX_ERROR;
}
for (element = elements; element->name_conf_offset >= 0; element++)
{
cur_key = (ngx_str_t*)((u_char*)conf + element->name_conf_offset);
if (cur_key->len == 0)
{
break;
}
hash_key = ngx_array_push(&elements_arr);
if (hash_key == NULL)
{
return NGX_ERROR;
}
hash_key->key = *cur_key;
hash_key->key_hash = ngx_hash_key_lc(cur_key->data, cur_key->len);
hash_key->value = element;
}
hash.hash = output;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = hash_name;
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, elements_arr.elts, elements_arr.nelts) != NGX_OK)
{
return NGX_ERROR;
}
return NGX_OK;
}
void* init_hash(ngx_pool_t *pool, ngx_hash_keys_arrays_t *ha, ngx_hash_combined_t *hash)
{
ngx_hash_init_t hinit;
ngx_cacheline_size = 32; //here this variable for nginx must be defined
hinit.hash = NULL; //if hinit.hash is NULL, it will alloc memory for it in ngx_hash_init
hinit.key = &ngx_hash_key_lc; //hash function
hinit.max_size = Max_Size;
hinit.bucket_size = Bucket_Size;
hinit.name = "my_hash_sample";
hinit.pool = pool; //the hash table exists in the memory pool
hinit.temp_pool = ha->temp_pool;
if (ha->keys.nelts) { //无通配
hinit.hash = &hash->hash;
if (ngx_hash_init(&hinit, ha->keys.elts, ha->keys.nelts) != NGX_OK) {
goto failed;
}
}
if (ha->dns_wc_head.nelts) { //前缀通配
hinit.hash = NULL;
ngx_qsort(ha->dns_wc_head.elts, (size_t) ha->dns_wc_head.nelts,
sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
if (ngx_hash_wildcard_init(&hinit, ha->dns_wc_head.elts,
ha->dns_wc_head.nelts)
!= NGX_OK)
{
goto failed;
}
hash->wc_head = (ngx_hash_wildcard_t *) hinit.hash;
}
if (ha->dns_wc_tail.nelts) { //后缀通配
ngx_qsort(ha->dns_wc_tail.elts, (size_t) ha->dns_wc_tail.nelts,
sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
hinit.hash = NULL;
if (ngx_hash_wildcard_init(&hinit, ha->dns_wc_tail.elts,
ha->dns_wc_tail.nelts)
!= NGX_OK)
{
goto failed;
}
hash->wc_tail = (ngx_hash_wildcard_t *) hinit.hash;
}
//ngx_destroy_pool(ha->temp_pool);
return hash;
failed:
//ngx_destroy_pool(ha->temp_pool);
return NULL;
}
ngx_int_t
ngx_child_request_init(ngx_conf_t *cf)
{
ngx_child_request_hide_header_t *h;
ngx_array_t hide_headers_arr;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
// Note: need to install a header filter in order to support dumping requests -
// the headers of the parent request need to be sent before any body data is written
ngx_http_next_header_filter = ngx_http_top_header_filter;
ngx_http_top_header_filter = ngx_child_request_header_filter;
// initialize hide_headers_hash
if (ngx_array_init(
&hide_headers_arr,
cf->temp_pool,
sizeof(hide_headers) / sizeof(hide_headers[0]),
sizeof(ngx_hash_key_t)) != NGX_OK)
{
return NGX_ERROR;
}
for (h = hide_headers; h->name.len; h++)
{
hk = ngx_array_push(&hide_headers_arr);
if (hk == NULL)
{
return NGX_ERROR;
}
hk->key = h->name;
hk->key_hash = ngx_hash_key_lc(h->name.data, h->name.len);
hk->value = h;
}
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "vod_hide_headers_hash";
hash.hash = &hide_headers_hash;
hash.key = ngx_hash_key_lc;
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, hide_headers_arr.elts, hide_headers_arr.nelts) != NGX_OK)
{
return NGX_ERROR;
}
return NGX_OK;
}
static char *
ngx_http_srcache_init_main_conf(ngx_conf_t *cf, void *conf)
{
ngx_http_srcache_main_conf_t *smcf = conf;
ngx_array_t headers_in;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
ngx_http_srcache_header_t *header;
/* srcache_headers_in_hash */
if (ngx_array_init(&headers_in, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
for (header = ngx_http_srcache_headers_in; header->name.len; header++) {
hk = ngx_array_push(&headers_in);
if (hk == NULL) {
return NGX_CONF_ERROR;
}
hk->key = header->name;
hk->key_hash = ngx_hash_key_lc(header->name.data, header->name.len);
hk->value = header;
}
hash.hash = &smcf->headers_in_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "srcache_headers_in_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, headers_in.elts, headers_in.nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
ngx_hash_t* init_hash(ngx_pool_t *pool, ngx_array_t *array)
{
ngx_int_t result;
ngx_hash_init_t hinit;
ngx_cacheline_size = 32; //here this variable for nginx must be defined
hinit.hash = NULL; //if hinit.hash is NULL, it will alloc memory for it in ngx_hash_init
hinit.key = &ngx_hash_key_lc; //hash function
hinit.max_size = Max_Size;
hinit.bucket_size = Bucket_Size;
hinit.name = "my_hash_sample";
hinit.pool = pool; //the hash table exists in the memory pool
hinit.temp_pool = NULL;
result = ngx_hash_init(&hinit, (ngx_hash_key_t*)array->elts, array->nelts);
if (result != NGX_OK)
return NULL;
return hinit.hash;
}
ngx_int_t
ngx_http_yy_sec_waf_init_tfns_in_hash(ngx_conf_t *cf,
ngx_hash_t *tfns_in_hash)
{
ngx_array_t tfns;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
re_tfns_metadata *metadata;
if (ngx_array_init(&tfns, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_ERROR;
}
for (metadata = tfns_metadata; metadata->name.len; metadata++) {
hk = ngx_array_push(&tfns);
if (hk == NULL) {
return NGX_ERROR;
}
hk->key = metadata->name;
hk->key_hash = ngx_hash_key_lc(metadata->name.data, metadata->name.len);
hk->value = metadata;
}
hash.hash = tfns_in_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "tfns_in_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, tfns.elts, tfns.nelts) != NGX_OK) {
return NGX_ERROR;
}
return NGX_OK;
}
static ngx_int_t ngx_http_redis_init_handle(ngx_conf_t *cf,
ngx_http_redis_loc_conf_t *mlcf)
{
ngx_array_t commands;
ngx_http_redis_command_process_t *command;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
if (ngx_array_init(&commands, cf->temp_pool, 32, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_ERROR;
}
for (command = ngx_http_redis_command_proc; command->name.len; command++) {
hk = ngx_array_push(&commands);
if (hk == NULL) {
return NGX_ERROR;
}
hk->key = command->name;
hk->key_hash = ngx_hash_key_lc(command->name.data, command->name.len);
hk->value = command;
}
hash.hash = &mlcf->command_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "ngx_http_redis_command_proc_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, commands.elts, commands.nelts) != NGX_OK) {
return NGX_ERROR;
}
return NGX_OK;
}
static ngx_int_t ngx_http_small_light_header_filter(ngx_http_request_t *r)
{
ngx_http_small_light_conf_t *srv_conf;
ngx_http_small_light_conf_t *loc_conf;
ngx_http_small_light_ctx_t *ctx;
ngx_hash_init_t hash_init;
ngx_str_t define_pattern;
char *converter;
if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED ||
r->headers_out.content_length_n == 0)
{
return ngx_http_next_header_filter(r);
}
srv_conf = ngx_http_get_module_srv_conf(r, ngx_http_small_light_module);
loc_conf = ngx_http_get_module_loc_conf(r, ngx_http_small_light_module);
if (!loc_conf->enable) {
return ngx_http_next_header_filter(r);
}
if (!loc_conf->enable_getparam_mode) {
if(ngx_http_small_light_parse_define_pattern(r, &r->unparsed_uri, &define_pattern) != NGX_OK) {
return ngx_http_next_header_filter(r);
}
}
ctx = ngx_http_get_module_ctx(r, ngx_http_small_light_module);
if (ctx) {
ngx_http_set_ctx(r, NULL, ngx_http_small_light_module);
return ngx_http_next_header_filter(r);
}
if ((ctx = ngx_pcalloc(r->pool, sizeof(*ctx))) == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to allocate memory from r->pool %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
ctx->params.keys.pool = r->pool;
ctx->params.temp_pool = r->pool;
if (ngx_hash_keys_array_init(&ctx->params, NGX_HASH_SMALL) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to init hash keys for parameters %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
if (loc_conf->enable_getparam_mode) {
if (ngx_http_small_light_init_getparams(r, ctx, srv_conf) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to analyze parameters:%V %s:%d",
&define_pattern,
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
} else {
if (ngx_http_small_light_init_params(r, ctx, &define_pattern, srv_conf) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to analyze parameters:%V %s:%d",
&define_pattern,
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
}
hash_init.hash = &ctx->hash;
hash_init.key = ngx_hash_key_lc;
hash_init.max_size = 128;
hash_init.bucket_size = ngx_cacheline_size;
hash_init.name = "small_light_init_params";
hash_init.pool = ctx->params.keys.pool;
hash_init.temp_pool = NULL;
if (ngx_hash_init(&hash_init, ctx->params.keys.elts, ctx->params.keys.nelts) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to init hash table for parameters %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
ctx->inf = (char *)r->headers_out.content_type.data;
ctx->material_dir = &srv_conf->material_dir;
ctx->imlib2_temp_dir = loc_conf->imlib2_temp_dir;
if (r->headers_out.content_length_n < 0) {
ctx->content_length = loc_conf->buffer_size;
} else {
ctx->content_length = r->headers_out.content_length_n;
}
converter = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "e");
if (ngx_strcmp(converter, NGX_HTTP_SMALL_LIGHT_CONVERTER_IMAGEMAGICK) == 0) {
ctx->converter.init = ngx_http_small_light_imagemagick_init;
ctx->converter.term = ngx_http_small_light_imagemagick_term;
ctx->converter.process = ngx_http_small_light_imagemagick_process;
ctx->ictx = ngx_pcalloc(r->pool, sizeof(ngx_http_small_light_imagemagick_ctx_t));
#ifdef NGX_HTTP_SMALL_LIGHT_IMLIB2_ENABLED
} else if (ngx_strcmp(converter, NGX_HTTP_SMALL_LIGHT_CONVERTER_IMLIB2) == 0) {
ctx->converter.init = ngx_http_small_light_imlib2_init;
ctx->converter.term = ngx_http_small_light_imlib2_term;
ctx->converter.process = ngx_http_small_light_imlib2_process;
ctx->ictx = ngx_pcalloc(r->pool, sizeof(ngx_http_small_light_imlib2_ctx_t));
#endif
#ifdef NGX_HTTP_SMALL_LIGHT_GD_ENABLED
} else if (ngx_strcmp(converter, NGX_HTTP_SMALL_LIGHT_CONVERTER_GD) == 0) {
ctx->converter.init = ngx_http_small_light_gd_init;
ctx->converter.term = ngx_http_small_light_gd_term;
ctx->converter.process = ngx_http_small_light_gd_process;
ctx->ictx = ngx_pcalloc(r->pool, sizeof(ngx_http_small_light_gd_ctx_t));
#endif
} else {
ctx->converter.init = ngx_http_small_light_imagemagick_init;
ctx->converter.term = ngx_http_small_light_imagemagick_term;
ctx->converter.process = ngx_http_small_light_imagemagick_process;
ctx->ictx = ngx_pcalloc(r->pool, sizeof(ngx_http_small_light_imagemagick_ctx_t));
}
if (ctx->ictx == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to allocate memory from r->pool %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
ngx_http_set_ctx(r, ctx, ngx_http_small_light_module);
if (r->headers_out.refresh) {
r->headers_out.refresh->hash = 0;
}
r->main_filter_need_in_memory = 1;
r->allow_ranges = 0;
return NGX_OK;
}
static char *
ngx_http_referer_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_referer_conf_t *prev = parent;
ngx_http_referer_conf_t *conf = child;
ngx_uint_t n;
ngx_hash_init_t hash;
ngx_http_server_name_t *sn;
ngx_http_core_srv_conf_t *cscf;
if (conf->keys == NULL) {
conf->hash = prev->hash;
#if (NGX_PCRE)
ngx_conf_merge_ptr_value(conf->regex, prev->regex, NULL);
ngx_conf_merge_ptr_value(conf->server_name_regex,
prev->server_name_regex, NULL);
#endif
ngx_conf_merge_value(conf->no_referer, prev->no_referer, 0);
ngx_conf_merge_value(conf->blocked_referer, prev->blocked_referer, 0);
ngx_conf_merge_uint_value(conf->referer_hash_max_size,
prev->referer_hash_max_size, 2048);
ngx_conf_merge_uint_value(conf->referer_hash_bucket_size,
prev->referer_hash_bucket_size, 64);
return NGX_CONF_OK;
}
if (conf->server_names == 1) {
cscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_core_module);
sn = cscf->server_names.elts;
for (n = 0; n < cscf->server_names.nelts; n++) {
#if (NGX_PCRE)
if (sn[n].regex) {
if (ngx_http_add_regex_server_name(cf, conf, sn[n].regex)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
continue;
}
#endif
if (ngx_http_add_referer(cf, conf->keys, &sn[n].name, NULL)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
}
}
if ((conf->no_referer == 1 || conf->blocked_referer == 1)
&& conf->keys->keys.nelts == 0
&& conf->keys->dns_wc_head.nelts == 0
&& conf->keys->dns_wc_tail.nelts == 0)
{
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"the \"none\" or \"blocked\" referers are specified "
"in the \"valid_referers\" directive "
"without any valid referer");
return NGX_CONF_ERROR;
}
ngx_conf_merge_uint_value(conf->referer_hash_max_size,
prev->referer_hash_max_size, 2048);
ngx_conf_merge_uint_value(conf->referer_hash_bucket_size,
prev->referer_hash_bucket_size, 64);
conf->referer_hash_bucket_size = ngx_align(conf->referer_hash_bucket_size,
ngx_cacheline_size);
hash.key = ngx_hash_key_lc;
hash.max_size = conf->referer_hash_max_size;
hash.bucket_size = conf->referer_hash_bucket_size;
hash.name = "referer_hash";
hash.pool = cf->pool;
if (conf->keys->keys.nelts) {
hash.hash = &conf->hash.hash;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, conf->keys->keys.elts, conf->keys->keys.nelts)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
}
if (conf->keys->dns_wc_head.nelts) {
ngx_qsort(conf->keys->dns_wc_head.elts,
(size_t) conf->keys->dns_wc_head.nelts,
sizeof(ngx_hash_key_t),
ngx_http_cmp_referer_wildcards);
hash.hash = NULL;
hash.temp_pool = cf->temp_pool;
if (ngx_hash_wildcard_init(&hash, conf->keys->dns_wc_head.elts,
conf->keys->dns_wc_head.nelts)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
conf->hash.wc_head = (ngx_hash_wildcard_t *) hash.hash;
}
if (conf->keys->dns_wc_tail.nelts) {
ngx_qsort(conf->keys->dns_wc_tail.elts,
(size_t) conf->keys->dns_wc_tail.nelts,
sizeof(ngx_hash_key_t),
ngx_http_cmp_referer_wildcards);
hash.hash = NULL;
hash.temp_pool = cf->temp_pool;
if (ngx_hash_wildcard_init(&hash, conf->keys->dns_wc_tail.elts,
conf->keys->dns_wc_tail.nelts)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
conf->hash.wc_tail = (ngx_hash_wildcard_t *) hash.hash;
}
#if (NGX_PCRE)
ngx_conf_merge_ptr_value(conf->regex, prev->regex, NULL);
ngx_conf_merge_ptr_value(conf->server_name_regex, prev->server_name_regex,
NULL);
#endif
if (conf->no_referer == NGX_CONF_UNSET) {
conf->no_referer = 0;
}
if (conf->blocked_referer == NGX_CONF_UNSET) {
conf->blocked_referer = 0;
}
conf->keys = NULL;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_rtmp_init_event_handlers(ngx_conf_t *cf, ngx_rtmp_core_main_conf_t *cmcf)
{
ngx_hash_init_t calls_hash;
ngx_rtmp_handler_pt *eh;
ngx_rtmp_amf_handler_t *h;
ngx_hash_key_t *ha;
size_t n, m;
static size_t pm_events[] = {
NGX_RTMP_MSG_CHUNK_SIZE,
NGX_RTMP_MSG_ABORT,
NGX_RTMP_MSG_ACK,
NGX_RTMP_MSG_ACK_SIZE,
NGX_RTMP_MSG_BANDWIDTH
};
static size_t amf_events[] = {
NGX_RTMP_MSG_AMF_CMD,
NGX_RTMP_MSG_AMF_META,
NGX_RTMP_MSG_AMF_SHARED,
NGX_RTMP_MSG_AMF3_CMD,
NGX_RTMP_MSG_AMF3_META,
NGX_RTMP_MSG_AMF3_SHARED
};
/* init standard protocol events */
for(n = 0; n < sizeof(pm_events) / sizeof(pm_events[0]); ++n) {
eh = ngx_array_push(&cmcf->events[pm_events[n]]);
*eh = ngx_rtmp_protocol_message_handler;
}
/* init amf events */
for(n = 0; n < sizeof(amf_events) / sizeof(amf_events[0]); ++n) {
eh = ngx_array_push(&cmcf->events[amf_events[n]]);
*eh = ngx_rtmp_amf_message_handler;
}
/* init user protocol events */
eh = ngx_array_push(&cmcf->events[NGX_RTMP_MSG_USER]);
*eh = ngx_rtmp_user_message_handler;
/* aggregate to audio/video map */
eh = ngx_array_push(&cmcf->events[NGX_RTMP_MSG_AGGREGATE]);
*eh = ngx_rtmp_aggregate_message_handler;
/* init amf callbacks */
ngx_array_init(&cmcf->amf_arrays, cf->pool, 1, sizeof(ngx_hash_key_t));
h = cmcf->amf.elts;
for(n = 0; n < cmcf->amf.nelts; ++n, ++h) {
ha = cmcf->amf_arrays.elts;
for(m = 0; m < cmcf->amf_arrays.nelts; ++m, ++ha) {
if (h->name.len == ha->key.len
&& !ngx_strncmp(h->name.data, ha->key.data, ha->key.len))
{
break;
}
}
if (m == cmcf->amf_arrays.nelts) {
ha = ngx_array_push(&cmcf->amf_arrays);
ha->key = h->name;
ha->key_hash = ngx_hash_key_lc(ha->key.data, ha->key.len);
ha->value = ngx_array_create(cf->pool, 1,
sizeof(ngx_rtmp_handler_pt));
if (ha->value == NULL) {
return NGX_ERROR;
}
}
eh = ngx_array_push((ngx_array_t*)ha->value);
*eh = h->handler;
}
calls_hash.hash = &cmcf->amf_hash;
calls_hash.key = ngx_hash_key_lc;
calls_hash.max_size = 512;
calls_hash.bucket_size = ngx_cacheline_size;
calls_hash.name = "amf_hash";
calls_hash.pool = cf->pool;
calls_hash.temp_pool = NULL;
if (ngx_hash_init(&calls_hash, cmcf->amf_arrays.elts, cmcf->amf_arrays.nelts)
!= NGX_OK)
{
return NGX_ERROR;
}
return NGX_OK;
}
static ngx_int_t ngx_http_small_light_header_filter(ngx_http_request_t *r)
{
ngx_http_small_light_conf_t *srv_conf;
ngx_http_small_light_conf_t *loc_conf;
ngx_http_small_light_ctx_t *ctx;
ngx_hash_init_t hash;
ngx_str_t define_pattern;
if (r->headers_out.status == NGX_HTTP_NOT_MODIFIED) {
return ngx_http_next_header_filter(r);
}
srv_conf = ngx_http_get_module_srv_conf(r, ngx_http_small_light_module);
loc_conf = ngx_http_get_module_loc_conf(r, ngx_http_small_light_module);
if (!loc_conf->enable) {
return ngx_http_next_header_filter(r);
}
if(ngx_http_small_light_parse_define_pattern(r, &r->unparsed_uri, &define_pattern) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s:%d", __FUNCTION__, __LINE__);
return ngx_http_next_header_filter(r);
}
ctx = ngx_http_get_module_ctx(r, ngx_http_small_light_module);
if (ctx) {
ngx_http_set_ctx(r, NULL, ngx_http_small_light_module);
return ngx_http_next_header_filter(r);
}
if ((ctx = ngx_pcalloc(r->pool, sizeof(*ctx))) == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s:%d", __FUNCTION__, __LINE__);
return NGX_ERROR;
}
ngx_memzero(ctx, sizeof(ngx_http_small_light_ctx_t));
ctx->params.keys.pool = r->pool;
ctx->params.temp_pool = r->pool;
if (ngx_hash_keys_array_init(&ctx->params, NGX_HASH_SMALL) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s:%d", __FUNCTION__, __LINE__);
return NGX_ERROR;
}
if (ngx_http_small_light_init_params(r, ctx, &define_pattern, srv_conf) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s:%d", __FUNCTION__, __LINE__);
return NGX_ERROR;
}
hash.hash = &ctx->hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 128;
hash.bucket_size = ngx_cacheline_size;
hash.name = "small_light_init_params";
hash.pool = ctx->params.keys.pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, ctx->params.keys.elts, ctx->params.keys.nelts) != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "%s:%d", __FUNCTION__, __LINE__);
return NGX_ERROR;
}
ctx->inf = r->headers_out.content_type.data;
ctx->content_length = r->headers_out.content_length_n;
ngx_http_set_ctx(r, ctx, ngx_http_small_light_module);
if (r->headers_out.refresh) {
r->headers_out.refresh->hash = 0;
}
r->main_filter_need_in_memory = 1;
r->allow_ranges = 0;
return NGX_OK;
}
dvt_cache_t *dvt_cache_init(ngx_pool_t *pool)
{
dvt_cache_t *cache = ngx_palloc(pool, sizeof(dvt_cache_t));
cache->label_and_value_summary_json = NGX_CONF_UNSET_PTR;
cache->label_names = NGX_CONF_UNSET_PTR;
cache->label_ids = NGX_CONF_UNSET_PTR;
cache->label_value_names = NGX_CONF_UNSET_PTR;
cache->label_value_ids = NGX_CONF_UNSET_PTR;
uint64_t i, j;
ngx_str_t *jsn = NGX_CONF_UNSET_PTR;
ngx_array_t* series_collection;
ngx_array_t* lavs; // labels and values
ngx_str_t *current_str;
ngx_array_t *hash_elts;
ngx_hash_key_t *el;
ngx_array_t **ael;
ngx_hash_init_t hash_spec;
// ### json summary.
series_collection = load_test_exposition(pool);
if (series_collection)
{
lavs = lavs_from_series_set(series_collection, pool);
jsn = lavs_to_json(lavs, pool, pool);
}
cache->label_and_value_summary_json = jsn;
// ### label_id -> label_names array
cache->label_names = ngx_array_create(pool, 32, sizeof(ngx_str_t));
for (i=0; i<lavs->nelts; ++i)
{
current_str = ngx_array_push(cache->label_names);
*current_str = ((dvt_label_summary_info_t *)lavs->elts)[i].label_name;
}
// ### label_name -> label_id hash
hash_elts = ngx_array_create(pool, 32, sizeof(ngx_hash_key_t));
for (i=0; i<cache->label_names->nelts; ++i)
{
el = ngx_array_push(hash_elts);
el->key = ((ngx_str_t *)cache->label_names->elts)[i];
el->key_hash = ngx_hash_key(el->key.data, el->key.len);
el->value = (void *)(i + ARBITRARY_OFFSET_TO_AVOID_PTR_EQ_NULL);
}
cache->label_ids = ngx_palloc(pool, sizeof(ngx_hash_t));
hash_spec.hash = cache->label_ids;
hash_spec.key = ngx_hash_key;
hash_spec.max_size = 1024;
hash_spec.bucket_size = ngx_align(64, ngx_cacheline_size);
hash_spec.name = "label_ids";
hash_spec.pool = pool;
if (ngx_hash_init(&hash_spec, hash_elts->elts, hash_elts->nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
// ### label_value_names
cache->label_value_names = ngx_array_create(
pool, cache->label_names->nelts, sizeof(ngx_array_t *));
for (i=0; i<cache->label_names->nelts; ++i)
{
dvt_label_summary_info_t *labsum =
&(((dvt_label_summary_info_t *)lavs->elts)[i]);
ael = ngx_array_push(cache->label_value_names);
*ael = ngx_array_create(
pool, labsum->label_values->nelts, sizeof(ngx_str_t *));
for (j=0; j<labsum->label_values->nelts; ++j)
{
dvt_label_value_summary_info_t* labval_info
= &((dvt_label_value_summary_info_t *)labsum->label_values->elts)[j];
ngx_str_t *lval
= &labval_info->label_value_name;
ngx_str_t **p = ngx_array_push(*ael);
*p = lval;
}
}
// ### label_value_ids
cache->label_value_ids = ngx_array_create(
pool, cache->label_names->nelts, sizeof(ngx_hash_t));
for (i=0; i<cache->label_names->nelts; ++i)
{
hash_elts = ngx_array_create(pool, 32, sizeof(ngx_hash_key_t));
ngx_array_t *value_names
= ((ngx_array_t **)cache->label_value_names->elts)[i];
for (j=0; j<value_names->nelts; ++j)
{
el = ngx_array_push(hash_elts);
el->key = *((ngx_str_t **)value_names->elts)[j];
el->key_hash = ngx_hash_key(el->key.data, el->key.len);
el->value = (void *)(j + ARBITRARY_OFFSET_TO_AVOID_PTR_EQ_NULL);
}
ngx_hash_t *hel = ngx_array_push(cache->label_value_ids);
hash_spec.hash = hel;
hash_spec.key = ngx_hash_key;
hash_spec.max_size = 1024;
hash_spec.bucket_size = ngx_align(64, ngx_cacheline_size);
hash_spec.name = "label_value_ids";
hash_spec.pool = pool;
if (ngx_hash_init(&hash_spec, hash_elts->elts, hash_elts->nelts) != NGX_OK) {
return NGX_CONF_ERROR;
}
}
// TODO: some sort of partitioning.
// Probably binary.
// Goal is to keep as balanced as possible.
// ### all series
ngx_array_init(&cache->all_series, pool, 128, sizeof(uint32_t *));
for (i=0; i<series_collection->nelts; ++i)
{
ngx_array_t *series_kvps = ((ngx_array_t **)series_collection->elts)[i];
uint32_t **loc = ngx_array_push(&cache->all_series);
*loc = dvt_series_spec_from_kv_array(cache, series_kvps, pool);
dbg_ngx(dvt_series_spec_to_text(cache, *loc, pool), pool);
}
return cache;
}
ngx_int_t ngx_http_fetch_init_conf(
const ngx_http_fetch_essential_conf_t * essential_conf,
ngx_http_fetch_upstream_conf_t * uscf,
ngx_http_fetch_selector_t * selector)
{
if (!essential_conf || !essential_conf->cf)
{
return NGX_ERROR;
}
ngx_conf_t * cf = essential_conf->cf;
g_conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_fetch_conf_t));
ngx_http_fetch_conf_t * conf = g_conf;
conf->cycle = cf->cycle;
conf->request_pool_size = essential_conf->request_pool_size;
conf->log = cf->log;
conf->schema.len = sizeof("nginx://") - 1;
conf->schema.data = (u_char *) "nginx://";
ngx_http_upstream_main_conf_t * umcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_upstream_module);
if (!umcf)
{
return NGX_ERROR;
}
conf->headers_in_hash = umcf->headers_in_hash;
ngx_http_core_main_conf_t * cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
if (!cmcf)
{
return NGX_ERROR;
}
conf->variables = cmcf->variables.nelts;
conf->cscf = __get_core_srv_conf(cmcf, selector);
if (!conf->cscf || !conf->cscf->ctx
|| !conf->cscf->ctx->main_conf
|| !conf->cscf->ctx->srv_conf
|| !conf->cscf->ctx->loc_conf)
{
return NGX_ERROR;
}
conf->umcf.upstream = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_srv_conf_t));
if (!conf->umcf.upstream || !essential_conf->peers)
{
return NGX_ERROR;
}
conf->umcf.upstream->peer.data = essential_conf->peers; // ngx_http_upstream_init_round_robin_peer
ngx_http_upstream_conf_t * uc = &conf->umcf;
uc->upstream->peer.init = __init_peer;
__init_upstream_conf(uscf, uc);
// reference: ngx_http_upstream_init_main_conf
ngx_hash_init_t hash;
hash.hash = &uc->hide_headers_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "fetch_hide_headers_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
ngx_int_t rc = ngx_hash_init(&hash, NULL, 0);
if (NGX_OK != rc)
{
return NGX_ERROR;
}
if (NGX_OK != ngx_http_fetch_upstream_init(essential_conf->connection_cache_size, cf))
{
return NGX_ERROR;
}
return ngx_http_fetch_keepalive_init(essential_conf->keepalive_cache_size, cf);
}
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;
}
ngx_int_t
ngx_hash_wildcard_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names,
ngx_uint_t nelts)
{
size_t len, dot_len;
ngx_uint_t i, n, dot;
ngx_array_t curr_names, next_names;
ngx_hash_key_t *name, *next_name;
ngx_hash_init_t h;
ngx_hash_wildcard_t *wdc;
if (ngx_array_init(&curr_names, hinit->temp_pool, nelts,
sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_ERROR;
}
if (ngx_array_init(&next_names, hinit->temp_pool, nelts,
sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_ERROR;
}
for (n = 0; n < nelts; n = i) {
#if 0
ngx_log_error(NGX_LOG_ALERT, hinit->pool->log, 0,
"wc0: \"%V\"", &names[n].key);
#endif
dot = 0;
for (len = 0; len < names[n].key.len; len++) {
if (names[n].key.data[len] == '.') {
dot = 1;
break;
}
}
name = ngx_array_push(&curr_names);
if (name == NULL) {
return NGX_ERROR;
}
name->key.len = len;
name->key.data = names[n].key.data;
name->key_hash = hinit->key(name->key.data, name->key.len);
name->value = names[n].value;
#if 0
ngx_log_error(NGX_LOG_ALERT, hinit->pool->log, 0,
"wc1: \"%V\" %ui", &name->key, dot);
#endif
dot_len = len + 1;
if (dot) {
len++;
}
next_names.nelts = 0;
if (names[n].key.len != len) {
next_name = ngx_array_push(&next_names);
if (next_name == NULL) {
return NGX_ERROR;
}
next_name->key.len = names[n].key.len - len;
next_name->key.data = names[n].key.data + len;
next_name->key_hash = 0;
next_name->value = names[n].value;
#if 0
ngx_log_error(NGX_LOG_ALERT, hinit->pool->log, 0,
"wc2: \"%V\"", &next_name->key);
#endif
}
for (i = n + 1; i < nelts; i++) {
if (ngx_strncmp(names[n].key.data, names[i].key.data, len) != 0) {
break;
}
if (!dot
&& names[i].key.len > len
&& names[i].key.data[len] != '.')
{
break;
}
next_name = ngx_array_push(&next_names);
if (next_name == NULL) {
return NGX_ERROR;
}
next_name->key.len = names[i].key.len - dot_len;
next_name->key.data = names[i].key.data + dot_len;
next_name->key_hash = 0;
next_name->value = names[i].value;
#if 0
ngx_log_error(NGX_LOG_ALERT, hinit->pool->log, 0,
"wc3: \"%V\"", &next_name->key);
#endif
}
if (next_names.nelts) {
h = *hinit;
h.hash = NULL;
if (ngx_hash_wildcard_init(&h, (ngx_hash_key_t *) next_names.elts,
next_names.nelts)
!= NGX_OK)
{
return NGX_ERROR;
}
wdc = (ngx_hash_wildcard_t *) h.hash;
if (names[n].key.len == len) {
wdc->value = names[n].value;
}
name->value = (void *) ((uintptr_t) wdc | (dot ? 3 : 2));
} else if (dot) {
name->value = (void *) ((uintptr_t) name->value | 1);
}
}
if (ngx_hash_init(hinit, (ngx_hash_key_t *) curr_names.elts,
curr_names.nelts)
!= NGX_OK)
{
return NGX_ERROR;
}
return NGX_OK;
}
ngx_int_t
ngx_http_variables_init_vars(ngx_conf_t *cf)
{
ngx_uint_t i, n;
ngx_hash_key_t *key;
ngx_hash_init_t hash;
ngx_http_variable_t *v, *av;
ngx_http_core_main_conf_t *cmcf;
/* set the handlers for the indexed http variables */
cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
v = cmcf->variables.elts;
key = cmcf->variables_keys->keys.elts;
for (i = 0; i < cmcf->variables.nelts; i++) {
for (n = 0; n < cmcf->variables_keys->keys.nelts; n++) {
av = key[n].value;
if (av->get_handler
&& v[i].name.len == key[n].key.len
&& ngx_strncmp(v[i].name.data, key[n].key.data, v[i].name.len)
== 0)
{
v[i].get_handler = av->get_handler;
v[i].data = av->data;
av->flags |= NGX_HTTP_VAR_INDEXED;
v[i].flags = av->flags;
av->index = i;
goto next;
}
}
if (ngx_strncmp(v[i].name.data, "http_", 5) == 0) {
v[i].get_handler = ngx_http_variable_unknown_header_in;
v[i].data = (uintptr_t) &v[i].name;
continue;
}
if (ngx_strncmp(v[i].name.data, "sent_http_", 10) == 0) {
v[i].get_handler = ngx_http_variable_unknown_header_out;
v[i].data = (uintptr_t) &v[i].name;
continue;
}
if (ngx_strncmp(v[i].name.data, "upstream_http_", 14) == 0) {
v[i].get_handler = ngx_http_upstream_header_variable;
v[i].data = (uintptr_t) &v[i].name;
v[i].flags = NGX_HTTP_VAR_NOCACHEABLE;
continue;
}
if (ngx_strncmp(v[i].name.data, "cookie_", 7) == 0) {
v[i].get_handler = ngx_http_variable_cookie;
v[i].data = (uintptr_t) &v[i].name;
continue;
}
if (ngx_strncmp(v[i].name.data, "arg_", 4) == 0) {
v[i].get_handler = ngx_http_variable_argument;
v[i].data = (uintptr_t) &v[i].name;
v[i].flags = NGX_HTTP_VAR_NOCACHEABLE;
continue;
}
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"unknown \"%V\" variable", &v[i].name);
return NGX_ERROR;
next:
continue;
}
for (n = 0; n < cmcf->variables_keys->keys.nelts; n++) {
av = key[n].value;
if (av->flags & NGX_HTTP_VAR_NOHASH) {
key[n].key.data = NULL;
}
}
hash.hash = &cmcf->variables_hash;
hash.key = ngx_hash_key;
hash.max_size = cmcf->variables_hash_max_size;
hash.bucket_size = cmcf->variables_hash_bucket_size;
hash.name = "variables_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, cmcf->variables_keys->keys.elts,
cmcf->variables_keys->keys.nelts)
!= NGX_OK)
{
return NGX_ERROR;
}
cmcf->variables_keys = NULL;
return NGX_OK;
}
ngx_int_t
ngx_http_srcache_hide_headers_hash(ngx_conf_t *cf,
ngx_http_srcache_loc_conf_t *conf, ngx_http_srcache_loc_conf_t *prev,
ngx_str_t *default_hide_headers, ngx_hash_init_t *hash)
{
ngx_str_t *h;
ngx_uint_t i, j;
ngx_array_t hide_headers;
ngx_hash_key_t *hk;
if (conf->hide_headers == NGX_CONF_UNSET_PTR
&& conf->pass_headers == NGX_CONF_UNSET_PTR)
{
conf->hide_headers_hash = prev->hide_headers_hash;
if (conf->hide_headers_hash.buckets) {
return NGX_OK;
}
conf->hide_headers = prev->hide_headers;
conf->pass_headers = prev->pass_headers;
conf->hide_content_type = prev->hide_content_type;
conf->hide_last_modified = prev->hide_last_modified;
} else {
if (conf->hide_headers == NGX_CONF_UNSET_PTR) {
conf->hide_headers = prev->hide_headers;
}
if (conf->pass_headers == NGX_CONF_UNSET_PTR) {
conf->pass_headers = prev->pass_headers;
}
}
dd("init hide headers");
if (ngx_array_init(&hide_headers, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_ERROR;
}
for (h = default_hide_headers; h->len; h++) {
hk = ngx_array_push(&hide_headers);
if (hk == NULL) {
return NGX_ERROR;
}
hk->key = *h;
hk->key_hash = ngx_hash_key_lc(h->data, h->len);
hk->value = (void *) 1;
}
if (conf->hide_headers != NGX_CONF_UNSET_PTR) {
dd("hide headers not empty");
h = conf->hide_headers->elts;
for (i = 0; i < conf->hide_headers->nelts; i++) {
hk = hide_headers.elts;
for (j = 0; j < hide_headers.nelts; j++) {
if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
goto exist;
}
}
hk = ngx_array_push(&hide_headers);
if (hk == NULL) {
return NGX_ERROR;
}
hk->key = h[i];
hk->key_hash = ngx_hash_key_lc(h[i].data, h[i].len);
hk->value = (void *) 1;
if (h[i].len == sizeof("Last-Modified") - 1
&& ngx_strncasecmp(h[i].data, (u_char *) "Last-Modified",
sizeof("Last-Modified") - 1)
== 0)
{
conf->hide_last_modified = 1;
}
if (h[i].len == sizeof("Content-Type") - 1
&& ngx_strncasecmp(h[i].data, (u_char *) "Content-Type",
sizeof("Content-Type") - 1) == 0)
{
conf->hide_content_type = 1;
}
dd("adding header to hide headers: %.*s", (int) h[i].len,
h[i].data);
exist:
continue;
}
}
if (conf->pass_headers != NGX_CONF_UNSET_PTR) {
h = conf->pass_headers->elts;
hk = hide_headers.elts;
for (i = 0; i < conf->pass_headers->nelts; i++) {
for (j = 0; j < hide_headers.nelts; j++) {
if (hk[j].key.data == NULL) {
continue;
}
if (h[i].len == sizeof("Content-Type") - 1
&& ngx_strncasecmp(h[i].data, (u_char *) "Content-Type",
sizeof("Content-Type") - 1) == 0)
{
conf->hide_content_type = 0;
}
if (h[i].len == sizeof("Last-Modified") - 1
&& ngx_strncasecmp(h[i].data, (u_char *) "Last-Modified",
sizeof("Last-Modified") - 1) == 0)
{
conf->hide_last_modified = 0;
}
if (ngx_strcasecmp(h[i].data, hk[j].key.data) == 0) {
hk[j].key.data = NULL;
break;
}
}
}
}
hash->hash = &conf->hide_headers_hash;
hash->key = ngx_hash_key_lc;
hash->pool = cf->pool;
hash->temp_pool = NULL;
return ngx_hash_init(hash, hide_headers.elts, hide_headers.nelts);
}
ngx_int_t
ngx_stream_variables_init_vars(ngx_conf_t *cf)
{
ngx_uint_t i, n;
ngx_hash_key_t *key;
ngx_hash_init_t hash;
ngx_stream_variable_t *v, *av;
ngx_stream_core_main_conf_t *cmcf;
/* set the handlers for the indexed stream variables */
cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);
v = cmcf->variables.elts;
key = cmcf->variables_keys->keys.elts;
for (i = 0; i < cmcf->variables.nelts; i++) {
for (n = 0; n < cmcf->variables_keys->keys.nelts; n++) {
av = key[n].value;
if (v[i].name.len == key[n].key.len
&& ngx_strncmp(v[i].name.data, key[n].key.data, v[i].name.len)
== 0)
{
v[i].get_handler = av->get_handler;
v[i].data = av->data;
av->flags |= NGX_STREAM_VAR_INDEXED;
v[i].flags = av->flags;
av->index = i;
if (av->get_handler == NULL) {
break;
}
goto next;
}
}
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"unknown \"%V\" variable", &v[i].name);
return NGX_ERROR;
next:
continue;
}
for (n = 0; n < cmcf->variables_keys->keys.nelts; n++) {
av = key[n].value;
if (av->flags & NGX_STREAM_VAR_NOHASH) {
key[n].key.data = NULL;
}
}
hash.hash = &cmcf->variables_hash;
hash.key = ngx_hash_key;
hash.max_size = cmcf->variables_hash_max_size;
hash.bucket_size = cmcf->variables_hash_bucket_size;
hash.name = "variables_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, cmcf->variables_keys->keys.elts,
cmcf->variables_keys->keys.nelts)
!= NGX_OK)
{
return NGX_ERROR;
}
cmcf->variables_keys = NULL;
return NGX_OK;
}
static ngx_int_t
ngx_http_server_names(ngx_conf_t *cf, ngx_http_core_main_conf_t *cmcf,
ngx_http_conf_addr_t *addr)
{
ngx_int_t rc;
ngx_uint_t n, s;
ngx_hash_init_t hash;
ngx_hash_keys_arrays_t ha;
ngx_http_server_name_t *name;
ngx_http_core_srv_conf_t **cscfp;
#if (NGX_PCRE)
ngx_uint_t regex, i;
regex = 0;
#endif
ngx_memzero(&ha, sizeof(ngx_hash_keys_arrays_t));
ha.temp_pool = ngx_create_pool(16384, cf->log);
if (ha.temp_pool == NULL) {
return NGX_ERROR;
}
ha.pool = cf->pool;
if (ngx_hash_keys_array_init(&ha, NGX_HASH_LARGE) != NGX_OK) {
goto failed;
}
cscfp = addr->servers.elts;
for (s = 0; s < addr->servers.nelts; s++) {
name = cscfp[s]->server_names.elts;
for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
#if (NGX_PCRE)
if (name[n].regex) {
regex++;
continue;
}
#endif
rc = ngx_hash_add_key(&ha, &name[n].name, name[n].server,
NGX_HASH_WILDCARD_KEY);
if (rc == NGX_ERROR) {
return NGX_ERROR;
}
if (rc == NGX_DECLINED) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"invalid server name or wildcard \"%V\" on %s",
&name[n].name, addr->opt.addr);
return NGX_ERROR;
}
if (rc == NGX_BUSY) {
ngx_log_error(NGX_LOG_WARN, cf->log, 0,
"conflicting server name \"%V\" on %s, ignored",
&name[n].name, addr->opt.addr);
}
}
}
hash.key = ngx_hash_key_lc;
hash.max_size = cmcf->server_names_hash_max_size;
hash.bucket_size = cmcf->server_names_hash_bucket_size;
hash.name = "server_names_hash";
hash.pool = cf->pool;
if (ha.keys.nelts) {
hash.hash = &addr->hash;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, ha.keys.elts, ha.keys.nelts) != NGX_OK) {
goto failed;
}
}
if (ha.dns_wc_head.nelts) {
ngx_qsort(ha.dns_wc_head.elts, (size_t) ha.dns_wc_head.nelts,
sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
hash.hash = NULL;
hash.temp_pool = ha.temp_pool;
if (ngx_hash_wildcard_init(&hash, ha.dns_wc_head.elts,
ha.dns_wc_head.nelts)
!= NGX_OK)
{
goto failed;
}
addr->wc_head = (ngx_hash_wildcard_t *) hash.hash;
}
if (ha.dns_wc_tail.nelts) {
ngx_qsort(ha.dns_wc_tail.elts, (size_t) ha.dns_wc_tail.nelts,
sizeof(ngx_hash_key_t), ngx_http_cmp_dns_wildcards);
hash.hash = NULL;
hash.temp_pool = ha.temp_pool;
if (ngx_hash_wildcard_init(&hash, ha.dns_wc_tail.elts,
ha.dns_wc_tail.nelts)
!= NGX_OK)
{
goto failed;
}
addr->wc_tail = (ngx_hash_wildcard_t *) hash.hash;
}
ngx_destroy_pool(ha.temp_pool);
#if (NGX_PCRE)
if (regex == 0) {
return NGX_OK;
}
addr->nregex = regex;
addr->regex = ngx_palloc(cf->pool, regex * sizeof(ngx_http_server_name_t));
if (addr->regex == NULL) {
return NGX_ERROR;
}
i = 0;
for (s = 0; s < addr->servers.nelts; s++) {
name = cscfp[s]->server_names.elts;
for (n = 0; n < cscfp[s]->server_names.nelts; n++) {
if (name[n].regex) {
addr->regex[i++] = name[n];
}
}
}
#endif
return NGX_OK;
failed:
ngx_destroy_pool(ha.temp_pool);
return NGX_ERROR;
}
static ngx_int_t
ngx_http_wlr_finalize_hashtables(ngx_conf_t *cf, ngx_http_dummy_loc_conf_t *dlc) {
int get_sz = 0, headers_sz = 0, body_sz = 0, uri_sz = 0;
ngx_array_t *get_ar = NULL, *headers_ar = NULL, *body_ar = NULL, *uri_ar = NULL;
ngx_hash_key_t *arr_node;
ngx_hash_init_t hash_init;
uint i;
NX_LOG_DEBUG(_debug_whitelist_heavy,
NGX_LOG_EMERG, cf, 0,
"finalizing hashtables");
for (i = 0; i < dlc->tmp_wlr->nelts; i++) {
switch (((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].zone) {
case FILE_EXT:
case BODY:
body_sz++;
break;
case HEADERS:
headers_sz++;
break;
case URL:
uri_sz++;
break;
case ARGS:
get_sz++;
break;
case UNKNOWN:
default:
return (NGX_ERROR);
}
}
NX_LOG_DEBUG(_debug_whitelist_heavy,
NGX_LOG_EMERG, cf, 0,
"nb items : body:%d headers:%d uri:%d get:%d",
body_sz, headers_sz, uri_sz, get_sz);
if (get_sz)
get_ar = ngx_array_create(cf->pool, get_sz, sizeof(ngx_hash_key_t));
if (headers_sz)
headers_ar = ngx_array_create(cf->pool, headers_sz, sizeof(ngx_hash_key_t));
if (body_sz)
body_ar = ngx_array_create(cf->pool, body_sz, sizeof(ngx_hash_key_t));
if (uri_sz)
uri_ar = ngx_array_create(cf->pool, uri_sz, sizeof(ngx_hash_key_t));
for (i = 0; i < dlc->tmp_wlr->nelts; i++) {
switch (((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].zone) {
case FILE_EXT:
case BODY:
arr_node = (ngx_hash_key_t*) ngx_array_push(body_ar);
break;
case HEADERS:
arr_node = (ngx_hash_key_t*) ngx_array_push(headers_ar);
break;
case URL:
arr_node = (ngx_hash_key_t*) ngx_array_push(uri_ar);
break;
case ARGS:
arr_node = (ngx_hash_key_t*) ngx_array_push(get_ar);
break;
default:
return (NGX_ERROR);
}
if (!arr_node)
return (NGX_ERROR);
ngx_memset(arr_node, 0, sizeof(ngx_hash_key_t));
arr_node->key = *(((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].name);
arr_node->key_hash = ngx_hash_key_lc(((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].name->data,
((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].name->len);
arr_node->value = (void *) &(((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i]);
#ifdef SPECIAL__debug_whitelist_heavy
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "pushing new WL, zone:%d, target:%V, %d IDs",
((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].zone , ((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].name,
((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].ids->nelts);
unsigned int z;
for (z = 0; z < ((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].ids->nelts; z++)
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "id:%d",
((int *)((ngx_http_whitelist_rule_t *) dlc->tmp_wlr->elts)[i].ids->elts)[z]);
#endif
}
hash_init.key = &ngx_hash_key_lc;
hash_init.pool = cf->pool;
hash_init.temp_pool = NULL;
hash_init.max_size = 1024;
hash_init.bucket_size = 512;
if (body_ar) {
dlc->wlr_body_hash = (ngx_hash_t*) ngx_pcalloc(cf->pool, sizeof(ngx_hash_t));
hash_init.hash = dlc->wlr_body_hash;
hash_init.name = "wlr_body_hash";
if (ngx_hash_init(&hash_init, (ngx_hash_key_t*) body_ar->elts,
body_ar->nelts) != NGX_OK) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "$BODY hashtable init failed"); /* LCOV_EXCL_LINE */
return (NGX_ERROR); /* LCOV_EXCL_LINE */
}
else
NX_LOG_DEBUG(_debug_whitelist, NGX_LOG_EMERG, cf, 0, "$BODY hashtable init successed !");
}
if (uri_ar) {
dlc->wlr_url_hash = (ngx_hash_t*) ngx_pcalloc(cf->pool, sizeof(ngx_hash_t));
hash_init.hash = dlc->wlr_url_hash;
hash_init.name = "wlr_url_hash";
if (ngx_hash_init(&hash_init, (ngx_hash_key_t*) uri_ar->elts,
uri_ar->nelts) != NGX_OK) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "$URL hashtable init failed"); /* LCOV_EXCL_LINE */
return (NGX_ERROR); /* LCOV_EXCL_LINE */
}
else
NX_LOG_DEBUG(_debug_whitelist, NGX_LOG_EMERG, cf, 0, "$URL hashtable init successed !");
}
if (get_ar) {
dlc->wlr_args_hash = (ngx_hash_t*) ngx_pcalloc(cf->pool, sizeof(ngx_hash_t));
hash_init.hash = dlc->wlr_args_hash;
hash_init.name = "wlr_args_hash";
if (ngx_hash_init(&hash_init, (ngx_hash_key_t*) get_ar->elts,
get_ar->nelts) != NGX_OK) { /* LCOV_EXCL_LINE */
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "$ARGS hashtable init failed"); /* LCOV_EXCL_LINE */
return (NGX_ERROR);
}
else
NX_LOG_DEBUG(_debug_whitelist, NGX_LOG_EMERG, cf, 0, "$ARGS hashtable init successed %d !",
dlc->wlr_args_hash->size);
}
if (headers_ar) {
dlc->wlr_headers_hash = (ngx_hash_t*) ngx_pcalloc(cf->pool, sizeof(ngx_hash_t));
hash_init.hash = dlc->wlr_headers_hash;
hash_init.name = "wlr_headers_hash";
if (ngx_hash_init(&hash_init, (ngx_hash_key_t*) headers_ar->elts,
headers_ar->nelts) != NGX_OK) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "$HEADERS hashtable init failed"); /* LCOV_EXCL_LINE */
return (NGX_ERROR); /* LCOV_EXCL_LINE */
}
else
NX_LOG_DEBUG(_debug_whitelist, NGX_LOG_EMERG, cf, 0, "$HEADERS hashtable init successed %d !",
dlc->wlr_headers_hash->size);
}
return (NGX_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_map_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_map_conf_t *mcf = conf;
char *rv;
ngx_str_t *value, name;
ngx_conf_t save;
ngx_pool_t *pool;
ngx_hash_init_t hash;
ngx_http_map_ctx_t *map;
ngx_http_variable_t *var;
ngx_http_map_conf_ctx_t ctx;
ngx_http_compile_complex_value_t ccv;
if (mcf->hash_max_size == NGX_CONF_UNSET_UINT) {
mcf->hash_max_size = 2048;
}
if (mcf->hash_bucket_size == NGX_CONF_UNSET_UINT) {
mcf->hash_bucket_size = ngx_cacheline_size;
} else {
mcf->hash_bucket_size = ngx_align(mcf->hash_bucket_size,
ngx_cacheline_size);
}
map = ngx_pcalloc(cf->pool, sizeof(ngx_http_map_ctx_t));
if (map == NULL) {
return NGX_CONF_ERROR;
}
value = cf->args->elts;
ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));
ccv.cf = cf;
ccv.value = &value[1];
ccv.complex_value = &map->value;
if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
return NGX_CONF_ERROR;
}
name = value[2];
if (name.data[0] != '$') {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid variable name \"%V\"", &name);
return NGX_CONF_ERROR;
}
name.len--;
name.data++;
var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
if (var == NULL) {
return NGX_CONF_ERROR;
}
var->get_handler = ngx_http_map_variable;
var->data = (uintptr_t) map;
pool = ngx_create_pool(NGX_DEFAULT_POOL_SIZE, cf->log);
if (pool == NULL) {
return NGX_CONF_ERROR;
}
ctx.keys.pool = cf->pool;
ctx.keys.temp_pool = pool;
if (ngx_hash_keys_array_init(&ctx.keys, NGX_HASH_LARGE) != NGX_OK) {
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
ctx.values_hash = ngx_pcalloc(pool, sizeof(ngx_array_t) * ctx.keys.hsize);
if (ctx.values_hash == NULL) {
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
#if (NGX_PCRE)
if (ngx_array_init(&ctx.regexes, cf->pool, 2, sizeof(ngx_http_map_regex_t))
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
#endif
ctx.default_value = NULL;
ctx.cf = &save;
ctx.hostnames = 0;
ctx.no_cacheable = 0;
save = *cf;
cf->pool = pool;
cf->ctx = &ctx;
cf->handler = ngx_http_map;
cf->handler_conf = conf;
rv = ngx_conf_parse(cf, NULL);
*cf = save;
if (rv != NGX_CONF_OK) {
ngx_destroy_pool(pool);
return rv;
}
if (ctx.no_cacheable) {
var->flags |= NGX_HTTP_VAR_NOCACHEABLE;
}
map->default_value = ctx.default_value ? ctx.default_value:
&ngx_http_variable_null_value;
map->hostnames = ctx.hostnames;
hash.key = ngx_hash_key_lc;
hash.max_size = mcf->hash_max_size;
hash.bucket_size = mcf->hash_bucket_size;
hash.name = "map_hash";
hash.pool = cf->pool;
if (ctx.keys.keys.nelts) {
hash.hash = &map->map.hash.hash;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, ctx.keys.keys.elts, ctx.keys.keys.nelts)
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
}
if (ctx.keys.dns_wc_head.nelts) {
ngx_qsort(ctx.keys.dns_wc_head.elts,
(size_t) ctx.keys.dns_wc_head.nelts,
sizeof(ngx_hash_key_t), ngx_http_map_cmp_dns_wildcards);
hash.hash = NULL;
hash.temp_pool = pool;
if (ngx_hash_wildcard_init(&hash, ctx.keys.dns_wc_head.elts,
ctx.keys.dns_wc_head.nelts)
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
map->map.hash.wc_head = (ngx_hash_wildcard_t *) hash.hash;
}
if (ctx.keys.dns_wc_tail.nelts) {
ngx_qsort(ctx.keys.dns_wc_tail.elts,
(size_t) ctx.keys.dns_wc_tail.nelts,
sizeof(ngx_hash_key_t), ngx_http_map_cmp_dns_wildcards);
hash.hash = NULL;
hash.temp_pool = pool;
if (ngx_hash_wildcard_init(&hash, ctx.keys.dns_wc_tail.elts,
ctx.keys.dns_wc_tail.nelts)
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
map->map.hash.wc_tail = (ngx_hash_wildcard_t *) hash.hash;
}
#if (NGX_PCRE)
if (ctx.regexes.nelts) {
map->map.regex = ctx.regexes.elts;
map->map.nregex = ctx.regexes.nelts;
}
#endif
ngx_destroy_pool(pool);
return rv;
}
static char *
ngx_http_referer_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
ngx_http_referer_conf_t *prev = parent;
ngx_http_referer_conf_t *conf = child;
ngx_hash_init_t hash;
if (conf->keys == NULL) {
conf->hash = prev->hash;
#if (NGX_PCRE)
ngx_conf_merge_ptr_value(conf->regex, prev->regex, NULL);
#endif
ngx_conf_merge_value(conf->no_referer, prev->no_referer, 0);
ngx_conf_merge_value(conf->blocked_referer, prev->blocked_referer, 0);
return NGX_CONF_OK;
}
if ((conf->no_referer == 1 || conf->blocked_referer == 1)
&& conf->keys->keys.nelts == 0
&& conf->keys->dns_wc_head.nelts == 0
&& conf->keys->dns_wc_tail.nelts == 0)
{
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"the \"none\" or \"blocked\" referers are specified "
"in the \"valid_referers\" directive "
"without any valid referer");
return NGX_CONF_ERROR;
}
hash.key = ngx_hash_key_lc;
hash.max_size = 2048; /* TODO: referer_hash_max_size; */
hash.bucket_size = 64; /* TODO: referer_hash_bucket_size; */
hash.name = "referers_hash";
hash.pool = cf->pool;
if (conf->keys->keys.nelts) {
hash.hash = &conf->hash.hash;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, conf->keys->keys.elts, conf->keys->keys.nelts)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
}
if (conf->keys->dns_wc_head.nelts) {
ngx_qsort(conf->keys->dns_wc_head.elts,
(size_t) conf->keys->dns_wc_head.nelts,
sizeof(ngx_hash_key_t),
ngx_http_cmp_referer_wildcards);
hash.hash = NULL;
hash.temp_pool = cf->temp_pool;
if (ngx_hash_wildcard_init(&hash, conf->keys->dns_wc_head.elts,
conf->keys->dns_wc_head.nelts)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
conf->hash.wc_head = (ngx_hash_wildcard_t *) hash.hash;
}
if (conf->keys->dns_wc_tail.nelts) {
ngx_qsort(conf->keys->dns_wc_tail.elts,
(size_t) conf->keys->dns_wc_tail.nelts,
sizeof(ngx_hash_key_t),
ngx_http_cmp_referer_wildcards);
hash.hash = NULL;
hash.temp_pool = cf->temp_pool;
if (ngx_hash_wildcard_init(&hash, conf->keys->dns_wc_tail.elts,
conf->keys->dns_wc_tail.nelts)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
conf->hash.wc_tail = (ngx_hash_wildcard_t *) hash.hash;
}
#if (NGX_PCRE)
ngx_conf_merge_ptr_value(conf->regex, prev->regex, NULL);
#endif
if (conf->no_referer == NGX_CONF_UNSET) {
conf->no_referer = 0;
}
if (conf->blocked_referer == NGX_CONF_UNSET) {
conf->blocked_referer = 0;
}
conf->keys = NULL;
return NGX_CONF_OK;
}
static ngx_int_t
merge_headers(ngx_conf_t *cf, passenger_loc_conf_t *conf, passenger_loc_conf_t *prev)
{
u_char *p;
size_t size;
uintptr_t *code;
ngx_uint_t i;
ngx_array_t headers_names, headers_merged;
ngx_keyval_t *src, *s;
ngx_hash_key_t *hk;
ngx_hash_init_t hash;
ngx_http_script_compile_t sc;
ngx_http_script_copy_code_t *copy;
if (conf->headers_source == NULL) {
conf->flushes = prev->flushes;
conf->headers_set_len = prev->headers_set_len;
conf->headers_set = prev->headers_set;
conf->headers_set_hash = prev->headers_set_hash;
conf->headers_source = prev->headers_source;
}
if (conf->headers_set_hash.buckets
#if (NGX_HTTP_CACHE)
#if NGINX_VERSION_NUM >= 1007009
&& ((conf->upstream_config.cache == NGX_CONF_UNSET) == (prev->upstream_config.cache == NGX_CONF_UNSET))
#else
&& ((conf->upstream_config.cache == NGX_CONF_UNSET_PTR) == (prev->upstream_config.cache == NGX_CONF_UNSET_PTR))
#endif
#endif
)
{
return NGX_OK;
}
if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
!= NGX_OK)
{
return NGX_ERROR;
}
if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
!= NGX_OK)
{
return NGX_ERROR;
}
if (conf->headers_source == NULL) {
conf->headers_source = ngx_array_create(cf->pool, 4,
sizeof(ngx_keyval_t));
if (conf->headers_source == NULL) {
return NGX_ERROR;
}
}
conf->headers_set_len = ngx_array_create(cf->pool, 64, 1);
if (conf->headers_set_len == NULL) {
return NGX_ERROR;
}
conf->headers_set = ngx_array_create(cf->pool, 512, 1);
if (conf->headers_set == NULL) {
return NGX_ERROR;
}
src = conf->headers_source->elts;
for (i = 0; i < conf->headers_source->nelts; i++) {
s = ngx_array_push(&headers_merged);
if (s == NULL) {
return NGX_ERROR;
}
*s = src[i];
}
src = headers_merged.elts;
for (i = 0; i < headers_merged.nelts; i++) {
hk = ngx_array_push(&headers_names);
if (hk == NULL) {
return NGX_ERROR;
}
hk->key = src[i].key;
hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
hk->value = (void *) 1;
if (src[i].value.len == 0) {
continue;
}
if (ngx_http_script_variables_count(&src[i].value) == 0) {
copy = ngx_array_push_n(conf->headers_set_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len + sizeof(": ") - 1
+ src[i].value.len + sizeof(CRLF) - 1;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + sizeof(": ") - 1
+ src[i].value.len + sizeof(CRLF) - 1
+ sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->headers_set, size);
if (copy == NULL) {
return NGX_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len + sizeof(": ") - 1
+ src[i].value.len + sizeof(CRLF) - 1;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
*p++ = ':'; *p++ = ' ';
p = ngx_cpymem(p, src[i].value.data, src[i].value.len);
*p++ = CR; *p = LF;
} else {
copy = ngx_array_push_n(conf->headers_set_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len + sizeof(": ") - 1;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + sizeof(": ") - 1 + sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->headers_set, size);
if (copy == NULL) {
return NGX_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len + sizeof(": ") - 1;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
*p++ = ':'; *p = ' ';
ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
sc.cf = cf;
sc.source = &src[i].value;
sc.flushes = &conf->flushes;
sc.lengths = &conf->headers_set_len;
sc.values = &conf->headers_set;
if (ngx_http_script_compile(&sc) != NGX_OK) {
return NGX_ERROR;
}
copy = ngx_array_push_n(conf->headers_set_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = sizeof(CRLF) - 1;
size = (sizeof(ngx_http_script_copy_code_t)
+ sizeof(CRLF) - 1 + sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->headers_set, size);
if (copy == NULL) {
return NGX_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = sizeof(CRLF) - 1;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
*p++ = CR; *p = LF;
}
code = ngx_array_push_n(conf->headers_set_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_ERROR;
}
*code = (uintptr_t) NULL;
code = ngx_array_push_n(conf->headers_set, sizeof(uintptr_t));
if (code == NULL) {
return NGX_ERROR;
}
*code = (uintptr_t) NULL;
}
code = ngx_array_push_n(conf->headers_set_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_ERROR;
}
*code = (uintptr_t) NULL;
hash.hash = &conf->headers_set_hash;
hash.key = ngx_hash_key_lc;
hash.max_size = conf->headers_hash_max_size;
hash.bucket_size = conf->headers_hash_bucket_size;
hash.name = "passenger_headers_hash";
hash.pool = cf->pool;
hash.temp_pool = NULL;
return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
}
static char *
ngx_http_map_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_map_conf_t *mcf = conf;
char *rv;
ngx_str_t *value, name;
ngx_conf_t save;
ngx_pool_t *pool;
ngx_hash_init_t hash;
ngx_http_map_ctx_t *map;
ngx_http_variable_t *var;
ngx_http_map_conf_ctx_t ctx;
if (mcf->hash_max_size == NGX_CONF_UNSET_UINT) {
mcf->hash_max_size = 2048;
}
if (mcf->hash_bucket_size == NGX_CONF_UNSET_UINT) {
mcf->hash_bucket_size = ngx_cacheline_size;
} else {
mcf->hash_bucket_size = ngx_align(mcf->hash_bucket_size,
ngx_cacheline_size);
}
map = ngx_pcalloc(cf->pool, sizeof(ngx_http_map_ctx_t));
if (map == NULL) {
return NGX_CONF_ERROR;
}
value = cf->args->elts;
name = value[1];
name.len--;
name.data++;
map->index = ngx_http_get_variable_index(cf, &name);
if (map->index == NGX_ERROR) {
return NGX_CONF_ERROR;
}
name = value[2];
name.len--;
name.data++;
var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
if (var == NULL) {
return NGX_CONF_ERROR;
}
var->get_handler = ngx_http_map_variable;
var->data = (uintptr_t) map;
pool = ngx_create_pool(16384, cf->log);
if (pool == NULL) {
return NGX_CONF_ERROR;
}
ctx.keys.pool = cf->pool;
ctx.keys.temp_pool = pool;
if (ngx_hash_keys_array_init(&ctx.keys, NGX_HASH_LARGE) != NGX_OK) {
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
ctx.values_hash = ngx_pcalloc(pool, sizeof(ngx_array_t) * ctx.keys.hsize);
if (ctx.values_hash == NULL) {
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
ctx.default_value = NULL;
ctx.hostnames = 0;
save = *cf;
cf->pool = pool;
cf->ctx = &ctx;
cf->handler = ngx_http_map;
cf->handler_conf = conf;
rv = ngx_conf_parse(cf, NULL);
*cf = save;
if (rv != NGX_CONF_OK) {
ngx_destroy_pool(pool);
return rv;
}
map->default_value = ctx.default_value ? ctx.default_value:
&ngx_http_variable_null_value;
hash.key = ngx_hash_key_lc;
hash.max_size = mcf->hash_max_size;
hash.bucket_size = mcf->hash_bucket_size;
hash.name = "map_hash";
hash.pool = cf->pool;
if (ctx.keys.keys.nelts) {
hash.hash = &map->hash.hash;
hash.temp_pool = NULL;
if (ngx_hash_init(&hash, ctx.keys.keys.elts, ctx.keys.keys.nelts)
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
}
if (ctx.keys.dns_wc_head.nelts) {
ngx_qsort(ctx.keys.dns_wc_head.elts,
(size_t) ctx.keys.dns_wc_head.nelts,
sizeof(ngx_hash_key_t), ngx_http_map_cmp_dns_wildcards);
hash.hash = NULL;
hash.temp_pool = pool;
if (ngx_hash_wildcard_init(&hash, ctx.keys.dns_wc_head.elts,
ctx.keys.dns_wc_head.nelts)
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
map->hash.wc_head = (ngx_hash_wildcard_t *) hash.hash;
}
if (ctx.keys.dns_wc_tail.nelts) {
ngx_qsort(ctx.keys.dns_wc_tail.elts,
(size_t) ctx.keys.dns_wc_tail.nelts,
sizeof(ngx_hash_key_t), ngx_http_map_cmp_dns_wildcards);
hash.hash = NULL;
hash.temp_pool = pool;
if (ngx_hash_wildcard_init(&hash, ctx.keys.dns_wc_tail.elts,
ctx.keys.dns_wc_tail.nelts)
!= NGX_OK)
{
ngx_destroy_pool(pool);
return NGX_CONF_ERROR;
}
map->hash.wc_tail = (ngx_hash_wildcard_t *) hash.hash;
}
ngx_destroy_pool(pool);
return rv;
}
static ngx_int_t
ngx_http_themis_init(ngx_conf_t *cf)
{
void *c, **module_configs;
ngx_uint_t i, j;
ngx_hash_key_t *nodes;
ngx_hash_init_t configs_hash;
ngx_http_handler_pt *h;
ngx_themis_module_t *m;
ngx_http_core_main_conf_t *cmcf;
ngx_http_themis_main_conf_t *tmcf;
tmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_themis_module);
configs_hash.hash = &tmcf->configs_hash;
configs_hash.key = ngx_hash_key_lc;
configs_hash.max_size = tmcf->configs_hash_max_size;
configs_hash.bucket_size = tmcf->configs_hash_bucket_size;
configs_hash.name = "themis_configs_hash";
configs_hash.pool = cf->pool;
configs_hash.temp_pool = NULL;
nodes = tmcf->configs.elts;
for (i = 0; i < tmcf->configs.nelts; i++) {
module_configs =
ngx_pcalloc(cf->pool, sizeof(void *) * ngx_max_module);
nodes[i].value = module_configs;
for (j = 0; ngx_modules[j]; j++) {
if (ngx_modules[j]->type != NGX_THEMIS_MODULE) {
continue;
}
m = ngx_modules[j]->ctx;
if (!m->create_config) {
continue;
}
c = m->create_config(cf);
if (c == NULL) {
ngx_log_themis(NGX_LOG_ERR, cf->log, 0, "%V create conf error",
&m->name);
return NGX_ERROR;
}
module_configs[j] = c;
}
}
if (ngx_hash_init(&configs_hash, tmcf->configs.elts, tmcf->configs.nelts)
!= NGX_OK)
{
ngx_log_themis(NGX_LOG_ERR, cf->log, 0, "http themis init hash error");
return NGX_ERROR;
}
cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
if (h == NULL) {
return NGX_ERROR;
}
*h = ngx_http_themis_apply_conf_handler;
return NGX_OK;
}
