static char *
ngx_rtmp_exec_exec_static(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_rtmp_exec_main_conf_t *emcf = conf;
ngx_str_t *value;
size_t n, nargs;
ngx_str_t *s;
ngx_rtmp_exec_conf_t *ec;
value = cf->args->elts;
ec = ngx_array_push(&emcf->confs);
if (ec == NULL) {
return NGX_CONF_ERROR;
}
ec->cmd = value[1];
if (cf->args->nelts == 2) {
return NGX_CONF_OK;
}
nargs = cf->args->nelts - 2;
if (ngx_array_init(&ec->args, cf->pool, nargs,
sizeof(ngx_str_t)) != NGX_OK)
{
return NGX_CONF_ERROR;
}
s = ngx_array_push_n(&ec->args, nargs);
for (n = 2; n < cf->args->nelts; ++n, ++s) {
*s = value[n];
}
return NGX_CONF_OK;
}
static char* ngx_http_sla_pool (ngx_conf_t* cf, ngx_command_t* cmd, void* conf)
{
ngx_uint_t i;
ngx_str_t* value;
ngx_int_t ival;
ngx_uint_t* pval;
size_t size;
ngx_shm_zone_t* shm_zone;
ngx_http_sla_pool_t* pool;
ngx_http_sla_main_conf_t* config = conf;
value = cf->args->elts;
/* проверка off пула */
if (value[1].len == 3 && ngx_strncmp(value[1].data, "off", 3) == 0) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invaid sla_pool name \"%V\"", &value[1]);
return NGX_CONF_ERROR;
}
/* поиск среди имеющихся пулов */
pool = config->pools.elts;
for (i = 0; i < config->pools.nelts; i++) {
if (pool[i].name.len == value[1].len && ngx_strncmp(pool[i].name.data, value[1].data, value[1].len) == 0) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "duplicate sla_pool name \"%V\"", &value[1]);
return NGX_CONF_ERROR;
}
}
/* инициализация нового пула */
pool = ngx_array_push(&config->pools);
if (pool == NULL) {
return NGX_CONF_ERROR;
}
/* имя пула */
size = (value[1].len + 1) * sizeof(u_char);
if (size > NGX_HTTP_SLA_MAX_NAME_LEN) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "pool name too long");
return NGX_CONF_ERROR;
}
pool->name.data = ngx_palloc(cf->pool, size);
if (pool->name.data == NULL) {
return NGX_CONF_ERROR;
}
pool->name.len = value[1].len;
ngx_memcpy(pool->name.data, value[1].data, value[1].len);
pool->name.data[value[1].len] = 0;
/* массивы */
if (ngx_array_init(&pool->http, cf->pool, NGX_HTTP_SLA_MAX_HTTP_LEN, sizeof(ngx_uint_t)) != NGX_OK) {
return NGX_CONF_ERROR;
}
if (ngx_array_init(&pool->timings, cf->pool, NGX_HTTP_SLA_MAX_TIMINGS_LEN, sizeof(ngx_uint_t)) != NGX_OK) {
return NGX_CONF_ERROR;
}
if (ngx_array_init(&pool->quantiles, cf->pool, NGX_HTTP_SLA_MAX_QUANTILES_LEN, sizeof(ngx_uint_t)) != NGX_OK) {
return NGX_CONF_ERROR;
}
/* значения по умолчанию */
pool->shm_pool = NULL;
pool->shm_ctx = NULL;
pool->avg_window = 1600;
pool->min_timing = 0;
pool->generation = 0; /* установится при аллокации shm зоны */
/* парсинг параметров */
for (i = 2; i < cf->args->nelts; i++) {
if (ngx_strncmp(value[i].data, "timings=", 8) == 0) {
if (ngx_http_sla_parse_list(cf, &value[i], 8, &pool->timings, 0) != NGX_OK) {
return NGX_CONF_ERROR;
}
continue;
}
if (ngx_strncmp(value[i].data, "http=", 5) == 0) {
if (ngx_http_sla_parse_list(cf, &value[i], 5, &pool->http, 1) != NGX_OK) {
return NGX_CONF_ERROR;
}
continue;
}
if (ngx_strncmp(value[i].data, "avg_window=", 11) == 0) {
ival = ngx_atoi(&value[i].data[11], value[i].len - 11);
if (ival == NGX_ERROR || ival < 2) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "incorrect avg_window value \"%V\"", &value[i]);
return NGX_CONF_ERROR;
}
pool->avg_window = ival;
continue;
}
if (ngx_strncmp(value[i].data, "min_timing=", 11) == 0) {
ival = ngx_atoi(&value[i].data[11], value[i].len - 11);
if (ival == NGX_ERROR || ival < 0) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "incorrect min_timing value \"%V\"", &value[i]);
return NGX_CONF_ERROR;
}
pool->min_timing = ival;
continue;
}
if (value[i].len == 7 && ngx_strncmp(value[i].data, "default", 7) == 0) {
if (config->default_pool.data != NULL) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "default sla_pool \"%V\" already defined", &config->default_pool.data);
return NGX_CONF_ERROR;
}
size = pool->name.len + sizeof(u_char);
config->default_pool.len = pool->name.len;
config->default_pool.data = ngx_palloc(cf->pool, size);
if (config->default_pool.data == NULL) {
return NGX_CONF_ERROR;
}
ngx_memcpy(config->default_pool.data, pool->name.data, size);
continue;
}
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "invalid parameter \"%V\" for sla_pool", &value[i]);
return NGX_CONF_ERROR;
}
/* заполнение параметрами по умолчанию */
if (pool->timings.nelts == 0) {
pval = ngx_array_push_n(&pool->timings, 3);
pval[0] = 300;
pval[1] = 500;
pval[2] = 2000;
}
if (pool->http.nelts == 0) {
pval = ngx_array_push_n(&pool->http, 13);
pval[0] = 200; /* OK */
pval[1] = 301; /* Moved Permanently */
pval[2] = 302; /* Moved Temporarily */
pval[3] = 304; /* Not Modified */
pval[4] = 400; /* Bad Request */
pval[5] = 401; /* Unauthorized */
pval[6] = 403; /* Forbidden */
pval[7] = 404; /* Not Found */
pval[8] = 499; /* Nginx special */
pval[9] = 500; /* Internal Server Error */
pval[10] = 502; /* Bad Gateway */
pval[11] = 503; /* Service Unavailable */
pval[12] = 504; /* Gateway Timeout */
}
if (pool->quantiles.nelts == 0) {
pval = ngx_array_push_n(&pool->quantiles, 7);
pval[0] = 25; /* обязательный */
pval[1] = 50;
pval[2] = 75; /* обязательный */
pval[3] = 90;
pval[4] = 95;
pval[5] = 98;
pval[6] = 99;
}
/* заполнение "хвостов" для учета общего числа */
pval = ngx_array_push(&pool->timings);
*pval = -1;
pval = ngx_array_push(&pool->http);
*pval = -1;
/* проверка размеров */
if (pool->http.nelts > NGX_HTTP_SLA_MAX_HTTP_LEN) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "http list too long for sla_pool");
return NGX_CONF_ERROR;
}
if (pool->timings.nelts > NGX_HTTP_SLA_MAX_TIMINGS_LEN) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "timings list too long for sla_pool");
return NGX_CONF_ERROR;
}
/* создание зоны shred memory */
size = (sizeof(ngx_http_sla_pool_shm_t) * NGX_HTTP_SLA_MAX_COUNTERS_LEN / ngx_pagesize + 2) * ngx_pagesize;
shm_zone = ngx_shared_memory_add(cf, &pool->name, size, &ngx_http_sla_module);
if (shm_zone == NULL) {
return NGX_CONF_ERROR;
}
if (shm_zone->data != NULL) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "sla_pool \"%V\" is already allocated", &pool->name);
return NGX_CONF_ERROR;
}
shm_zone->data = &config->pools;
shm_zone->init = ngx_http_sla_init_zone;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_rtmp_exec_publish(ngx_rtmp_session_t *s, ngx_rtmp_publish_t *v)
{
ngx_rtmp_exec_main_conf_t *emcf;
ngx_rtmp_exec_app_conf_t *eacf;
ngx_rtmp_exec_t *e;
ngx_rtmp_exec_conf_t *ec;
ngx_rtmp_exec_ctx_t *ctx;
size_t n;
emcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_exec_module);
eacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_exec_module);
if (eacf == NULL || eacf->confs.nelts == 0) {
goto next;
}
if (s->auto_pushed) {
goto next;
}
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_exec_module);
if (ctx == NULL) {
ctx = ngx_pcalloc(s->connection->pool, sizeof(ngx_rtmp_exec_ctx_t));
if (ctx == NULL) {
return NGX_ERROR;
}
ngx_rtmp_set_ctx(s, ctx, ngx_rtmp_exec_module);
if (ngx_array_init(&ctx->execs, s->connection->pool, eacf->confs.nelts,
sizeof(ngx_rtmp_exec_t)) != NGX_OK)
{
return NGX_ERROR;
}
e = ngx_array_push_n(&ctx->execs, eacf->confs.nelts);
if (e == NULL) {
return NGX_ERROR;
}
ec = eacf->confs.elts;
for (n = 0; n < eacf->confs.nelts; ++n, ++e, ++ec) {
ngx_memzero(e, sizeof(*e));
e->conf = ec;
e->log = s->connection->log;
e->session = s;
e->kill_signal = emcf->kill_signal;
e->respawn_timeout = (eacf->respawn ? emcf->respawn_timeout :
NGX_CONF_UNSET_MSEC);
}
}
ngx_memcpy(ctx->name, v->name, NGX_RTMP_MAX_NAME);
ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
"exec: run %uz command(s)", ctx->execs.nelts);
e = ctx->execs.elts;
for (n = 0; n < ctx->execs.nelts; ++n, ++e) {
ngx_rtmp_exec_run(e);
}
next:
return next_publish(s, v);
}
static char *
ngx_event_debug_connection(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
#if (NGX_DEBUG)
ngx_event_conf_t *ecf = conf;
ngx_int_t rc;
ngx_str_t *value;
ngx_url_t u;
ngx_cidr_t c, *cidr;
ngx_uint_t i;
struct sockaddr_in *sin;
#if (NGX_HAVE_INET6)
struct sockaddr_in6 *sin6;
#endif
value = cf->args->elts;
#if (NGX_HAVE_UNIX_DOMAIN)
if (ngx_strcmp(value[1].data, "unix:") == 0) {
cidr = ngx_array_push(&ecf->debug_connection);
if (cidr == NULL) {
return NGX_CONF_ERROR;
}
cidr->family = AF_UNIX;
return NGX_CONF_OK;
}
#endif
rc = ngx_ptocidr(&value[1], &c);
if (rc != NGX_ERROR) {
if (rc == NGX_DONE) {
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
"low address bits of %V are meaningless",
&value[1]);
}
cidr = ngx_array_push(&ecf->debug_connection);
if (cidr == NULL) {
return NGX_CONF_ERROR;
}
*cidr = c;
return NGX_CONF_OK;
}
ngx_memzero(&u, sizeof(ngx_url_t));
u.host = value[1];
if (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
if (u.err) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"%s in debug_connection \"%V\"",
u.err, &u.host);
}
return NGX_CONF_ERROR;
}
cidr = ngx_array_push_n(&ecf->debug_connection, u.naddrs);
if (cidr == NULL) {
return NGX_CONF_ERROR;
}
ngx_memzero(cidr, u.naddrs * sizeof(ngx_cidr_t));
for (i = 0; i < u.naddrs; i++) {
cidr[i].family = u.addrs[i].sockaddr->sa_family;
switch (cidr[i].family) {
#if (NGX_HAVE_INET6)
case AF_INET6:
sin6 = (struct sockaddr_in6 *) u.addrs[i].sockaddr;
cidr[i].u.in6.addr = sin6->sin6_addr;
ngx_memset(cidr[i].u.in6.mask.s6_addr, 0xff, 16);
break;
#endif
default: /* AF_INET */
sin = (struct sockaddr_in *) u.addrs[i].sockaddr;
cidr[i].u.in.addr = sin->sin_addr.s_addr;
cidr[i].u.in.mask = 0xffffffff;
break;
}
}
#else
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
"\"debug_connection\" is ignored, you need to rebuild "
"nginx using --with-debug option to enable it");
#endif
return NGX_CONF_OK;
}
static char *
ngx_http_rewrite_if(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_rewrite_loc_conf_t *lcf = conf;
void *mconf;
char *rv;
u_char *elts;
ngx_uint_t i;
ngx_conf_t save;
ngx_http_module_t *module;
ngx_http_conf_ctx_t *ctx, *pctx;
ngx_http_core_loc_conf_t *clcf, *pclcf;
ngx_http_script_if_code_t *if_code;
ngx_http_rewrite_loc_conf_t *nlcf;
ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
if (ctx == NULL) {
return NGX_CONF_ERROR;
}
pctx = cf->ctx;
ctx->main_conf = pctx->main_conf;
ctx->srv_conf = pctx->srv_conf;
ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
if (ctx->loc_conf == NULL) {
return NGX_CONF_ERROR;
}
for (i = 0; ngx_modules[i]; i++) {
if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
continue;
}
module = ngx_modules[i]->ctx;
if (module->create_loc_conf) {
mconf = module->create_loc_conf(cf);
if (mconf == NULL) {
return NGX_CONF_ERROR;
}
ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
}
}
pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];
clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
clcf->loc_conf = ctx->loc_conf;
clcf->name = pclcf->name;
clcf->noname = 1;
if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
return NGX_CONF_ERROR;
}
if (ngx_http_rewrite_if_condition(cf, lcf) != NGX_CONF_OK) {
return NGX_CONF_ERROR;
}
if_code = ngx_array_push_n(lcf->codes, sizeof(ngx_http_script_if_code_t));
if (if_code == NULL) {
return NGX_CONF_ERROR;
}
if_code->code = ngx_http_script_if_code;
elts = lcf->codes->elts;
/* the inner directives must be compiled to the same code array */
nlcf = ctx->loc_conf[ngx_http_rewrite_module.ctx_index];
nlcf->codes = lcf->codes;
save = *cf;
cf->ctx = ctx;
if (pclcf->name.len == 0) {
if_code->loc_conf = NULL;
cf->cmd_type = NGX_HTTP_SIF_CONF;
} else {
if_code->loc_conf = ctx->loc_conf;
cf->cmd_type = NGX_HTTP_LIF_CONF;
}
rv = ngx_conf_parse(cf, NULL);
*cf = save;
if (rv != NGX_CONF_OK) {
return rv;
}
if (elts != lcf->codes->elts) {
if_code = (ngx_http_script_if_code_t *)
((u_char *) if_code + ((u_char *) lcf->codes->elts - elts));
}
if_code->next = (u_char *) lcf->codes->elts + lcf->codes->nelts
- (u_char *) if_code;
/* the code array belong to parent block */
nlcf->codes = NULL;
return NGX_CONF_OK;
}
static char *
ngx_http_reqstat_show_field(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_int_t valid, *index;
ngx_str_t *value, *user;
ngx_uint_t i, j;
ngx_http_reqstat_conf_t *rmcf, *rlcf;
rlcf = conf;
rmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_reqstat_module);
rlcf->user_select = ngx_array_create(cf->pool, cf->args->nelts - 1,
sizeof(ngx_int_t));
if (rlcf->user_select == NULL) {
return NGX_CONF_ERROR;
}
index = ngx_array_push_n(rlcf->user_select, cf->args->nelts - 1);
if (index == NULL) {
return NGX_CONF_ERROR;
}
value = cf->args->elts;
user = rmcf->user_defined_str->elts;
for (i = 1; i < cf->args->nelts; i++) {
valid = 0;
if (value[i].data[0] == '$') {
value[i].data++;
value[i].len--;
for (j = 0; j < rmcf->user_defined_str->nelts; j++) {
if (value[i].len != user[j].len
|| ngx_strncmp(value[i].data, user[j].data, value[i].len)
!= 0)
{
continue;
}
*index++ = NGX_HTTP_REQSTAT_RSRV + j;
valid = 1;
break;
}
} else {
for (j = 0; j < NGX_HTTP_REQSTAT_RSRV; j++) {
if (value[i].len != REQSTAT_RSRV_VARIABLES[j].name.len
|| ngx_strncmp(REQSTAT_RSRV_VARIABLES[j].name.data,
value[i].data, value[i].len) != 0)
{
continue;
}
*index++ = REQSTAT_RSRV_VARIABLES[j].index;
valid = 1;
break;
}
}
if (!valid) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"field \"%V\" does not exist",
&value[i]);
return NGX_CONF_ERROR;
}
}
return NGX_CONF_OK;
}
char *
passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
passenger_loc_conf_t *prev = parent;
passenger_loc_conf_t *conf = child;
u_char *p;
size_t size;
uintptr_t *code;
ngx_uint_t i;
ngx_str_t *prev_base_uris, *base_uri;
ngx_str_t *prev_union_station_filters, *union_station_filter;
ngx_keyval_t *src;
ngx_hash_init_t hash;
ngx_http_script_compile_t sc;
ngx_http_script_copy_code_t *copy;
#include "MergeLocationConfig.c"
if (prev->options_cache.data == NULL) {
cache_loc_conf_options(cf, prev);
}
cache_loc_conf_options(cf, conf);
if (prev->base_uris != NGX_CONF_UNSET_PTR) {
if (conf->base_uris == NGX_CONF_UNSET_PTR) {
conf->base_uris = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
if (conf->base_uris == NULL) {
return NGX_CONF_ERROR;
}
}
prev_base_uris = (ngx_str_t *) prev->base_uris->elts;
for (i = 0; i < prev->base_uris->nelts; i++) {
base_uri = (ngx_str_t *) ngx_array_push(conf->base_uris);
if (base_uri == NULL) {
return NGX_CONF_ERROR;
}
*base_uri = prev_base_uris[i];
}
}
if (prev->union_station_filters != NGX_CONF_UNSET_PTR) {
if (conf->union_station_filters == NGX_CONF_UNSET_PTR) {
conf->union_station_filters = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
if (conf->union_station_filters == NULL) {
return NGX_CONF_ERROR;
}
}
prev_union_station_filters = (ngx_str_t *) prev->union_station_filters->elts;
for (i = 0; i < prev->union_station_filters->nelts; i++) {
union_station_filter = (ngx_str_t *) ngx_array_push(conf->union_station_filters);
if (union_station_filter == NULL) {
return NGX_CONF_ERROR;
}
*union_station_filter = prev_union_station_filters[i];
}
}
/******************************/
/******************************/
if (conf->upstream_config.store != 0) {
ngx_conf_merge_value(conf->upstream_config.store,
prev->upstream_config.store, 0);
if (conf->upstream_config.store_lengths == NULL) {
conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
conf->upstream_config.store_values = prev->upstream_config.store_values;
}
}
ngx_conf_merge_uint_value(conf->upstream_config.store_access,
prev->upstream_config.store_access, 0600);
ngx_conf_merge_value(conf->upstream_config.buffering,
prev->upstream_config.buffering, 0);
ngx_conf_merge_value(conf->upstream_config.ignore_client_abort,
prev->upstream_config.ignore_client_abort, 0);
ngx_conf_merge_ptr_value(conf->upstream_config.local,
prev->upstream_config.local, NULL);
ngx_conf_merge_msec_value(conf->upstream_config.connect_timeout,
prev->upstream_config.connect_timeout, 12000000);
ngx_conf_merge_msec_value(conf->upstream_config.send_timeout,
prev->upstream_config.send_timeout, 12000000);
ngx_conf_merge_msec_value(conf->upstream_config.read_timeout,
prev->upstream_config.read_timeout, 12000000);
ngx_conf_merge_size_value(conf->upstream_config.send_lowat,
prev->upstream_config.send_lowat, 0);
ngx_conf_merge_size_value(conf->upstream_config.buffer_size,
prev->upstream_config.buffer_size,
16 * 1024);
ngx_conf_merge_bufs_value(conf->upstream_config.bufs, prev->upstream_config.bufs,
8, 16 * 1024);
if (conf->upstream_config.bufs.num < 2) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"there must be at least 2 \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
size = conf->upstream_config.buffer_size;
if (size < conf->upstream_config.bufs.size) {
size = conf->upstream_config.bufs.size;
}
ngx_conf_merge_size_value(conf->upstream_config.busy_buffers_size_conf,
prev->upstream_config.busy_buffers_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.busy_buffers_size = 2 * size;
} else {
conf->upstream_config.busy_buffers_size =
conf->upstream_config.busy_buffers_size_conf;
}
if (conf->upstream_config.busy_buffers_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_busy_buffers_size\" must be equal to or greater "
"than the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
if (conf->upstream_config.busy_buffers_size
> (conf->upstream_config.bufs.num - 1) * conf->upstream_config.bufs.size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_busy_buffers_size\" must be less than "
"the size of all \"passenger_buffers\" minus one buffer");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream_config.temp_file_write_size_conf,
prev->upstream_config.temp_file_write_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.temp_file_write_size = 2 * size;
} else {
conf->upstream_config.temp_file_write_size =
conf->upstream_config.temp_file_write_size_conf;
}
if (conf->upstream_config.temp_file_write_size < size) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_temp_file_write_size\" must be equal to or greater than "
"the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_size_value(conf->upstream_config.max_temp_file_size_conf,
prev->upstream_config.max_temp_file_size_conf,
NGX_CONF_UNSET_SIZE);
if (conf->upstream_config.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
conf->upstream_config.max_temp_file_size = 1024 * 1024 * 1024;
} else {
conf->upstream_config.max_temp_file_size =
conf->upstream_config.max_temp_file_size_conf;
}
if (conf->upstream_config.max_temp_file_size != 0
&& conf->upstream_config.max_temp_file_size < size)
{
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"passenger_max_temp_file_size\" must be equal to zero to disable "
"temporary files usage or must be equal to or greater than "
"the maximum of the value of \"passenger_buffer_size\" and "
"one of the \"passenger_buffers\"");
return NGX_CONF_ERROR;
}
ngx_conf_merge_bitmask_value(conf->upstream_config.ignore_headers,
prev->upstream_config.ignore_headers,
NGX_CONF_BITMASK_SET);
ngx_conf_merge_bitmask_value(conf->upstream_config.next_upstream,
prev->upstream_config.next_upstream,
(NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_ERROR
|NGX_HTTP_UPSTREAM_FT_TIMEOUT));
if (conf->upstream_config.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream_config.next_upstream = NGX_CONF_BITMASK_SET
|NGX_HTTP_UPSTREAM_FT_OFF;
}
ngx_conf_merge_path_value(cf,
&conf->upstream_config.temp_path,
prev->upstream_config.temp_path,
&ngx_http_proxy_temp_path);
#if (NGX_HTTP_CACHE)
ngx_conf_merge_ptr_value(conf->upstream_config.cache,
prev->upstream_config.cache, NULL);
if (conf->upstream_config.cache && conf->upstream_config.cache->data == NULL) {
ngx_shm_zone_t *shm_zone;
shm_zone = conf->upstream_config.cache;
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"\"scgi_cache\" zone \"%V\" is unknown",
&shm_zone->shm.name);
return NGX_CONF_ERROR;
}
ngx_conf_merge_uint_value(conf->upstream_config.cache_min_uses,
prev->upstream_config.cache_min_uses, 1);
ngx_conf_merge_bitmask_value(conf->upstream_config.cache_use_stale,
prev->upstream_config.cache_use_stale,
(NGX_CONF_BITMASK_SET
| NGX_HTTP_UPSTREAM_FT_OFF));
if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
conf->upstream_config.cache_use_stale = NGX_CONF_BITMASK_SET
| NGX_HTTP_UPSTREAM_FT_OFF;
}
if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
conf->upstream_config.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
}
if (conf->upstream_config.cache_methods == 0) {
conf->upstream_config.cache_methods = prev->upstream_config.cache_methods;
}
conf->upstream_config.cache_methods |= NGX_HTTP_GET | NGX_HTTP_HEAD;
ngx_conf_merge_ptr_value(conf->upstream_config.cache_bypass,
prev->upstream_config.cache_bypass, NULL);
ngx_conf_merge_ptr_value(conf->upstream_config.no_cache,
prev->upstream_config.no_cache, NULL);
ngx_conf_merge_ptr_value(conf->upstream_config.cache_valid,
prev->upstream_config.cache_valid, NULL);
if (conf->cache_key.value.data == NULL) {
conf->cache_key = prev->cache_key;
}
#if NGINX_VERSION_NUM >= 1002000
ngx_conf_merge_value(conf->upstream_config.cache_lock,
prev->upstream_config.cache_lock, 0);
ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_timeout,
prev->upstream_config.cache_lock_timeout, 5000);
#endif
#endif
ngx_conf_merge_value(conf->upstream_config.pass_request_headers,
prev->upstream_config.pass_request_headers, 1);
ngx_conf_merge_value(conf->upstream_config.pass_request_body,
prev->upstream_config.pass_request_body, 1);
ngx_conf_merge_value(conf->upstream_config.intercept_errors,
prev->upstream_config.intercept_errors, 0);
hash.max_size = 512;
hash.bucket_size = ngx_align(64, ngx_cacheline_size);
hash.name = "passenger_hide_headers_hash";
if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream_config,
&prev->upstream_config, headers_to_hide, &hash)
!= NGX_OK)
{
return NGX_CONF_ERROR;
}
if (conf->upstream_config.upstream == NULL) {
conf->upstream_config.upstream = prev->upstream_config.upstream;
}
if (conf->vars_source == NULL) {
conf->flushes = prev->flushes;
conf->vars_len = prev->vars_len;
conf->vars = prev->vars;
conf->vars_source = prev->vars_source;
if (conf->vars_source == NULL) {
return NGX_CONF_OK;
}
}
conf->vars_len = ngx_array_create(cf->pool, 64, 1);
if (conf->vars_len == NULL) {
return NGX_CONF_ERROR;
}
conf->vars = ngx_array_create(cf->pool, 512, 1);
if (conf->vars == NULL) {
return NGX_CONF_ERROR;
}
src = conf->vars_source->elts;
for (i = 0; i < conf->vars_source->nelts; i++) {
if (ngx_http_script_variables_count(&src[i].value) == 0) {
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len;
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].value.len;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + src[i].value.len
+ sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->vars, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len + src[i].value.len;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
ngx_memcpy(p, src[i].value.data, src[i].value.len);
} else {
copy = ngx_array_push_n(conf->vars_len,
sizeof(ngx_http_script_copy_code_t));
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = (ngx_http_script_code_pt)
ngx_http_script_copy_len_code;
copy->len = src[i].key.len;
size = (sizeof(ngx_http_script_copy_code_t)
+ src[i].key.len + sizeof(uintptr_t) - 1)
& ~(sizeof(uintptr_t) - 1);
copy = ngx_array_push_n(conf->vars, size);
if (copy == NULL) {
return NGX_CONF_ERROR;
}
copy->code = ngx_http_script_copy_code;
copy->len = src[i].key.len;
p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
ngx_memcpy(p, src[i].key.data, src[i].key.len);
ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
sc.cf = cf;
sc.source = &src[i].value;
sc.flushes = &conf->flushes;
sc.lengths = &conf->vars_len;
sc.values = &conf->vars;
if (ngx_http_script_compile(&sc) != NGX_OK) {
return NGX_CONF_ERROR;
}
}
code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
code = ngx_array_push_n(conf->vars, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
}
code = ngx_array_push_n(conf->vars_len, sizeof(uintptr_t));
if (code == NULL) {
return NGX_CONF_ERROR;
}
*code = (uintptr_t) NULL;
return NGX_CONF_OK;
}
static ngx_int_t ngx_let_get_node_value(ngx_http_request_t* r, ngx_let_node_t* node,
ngx_str_t* value)
{
ngx_http_variable_value_t* vv;
ngx_array_t args;
ngx_let_node_t** anode;
ngx_str_t* astr;
ngx_uint_t n;
ngx_int_t ret;
u_char* s;
int *cap;
ngx_int_t ncap;
if (node == NULL) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
"let NULL node");
return NGX_ERROR;
}
switch(node->type) {
case NGX_LTYPE_VARIABLE:
vv = ngx_http_get_indexed_variable(r, node->index);
if (vv == NULL || vv->not_found) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
"let variable %d not found", node->index);
return NGX_ERROR;
}
value->data = vv->data;
value->len = vv->len;
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"let getting variable %d: '%*s'", node->index, value->len, value->data);
break;
case NGX_LTYPE_CAPTURE:
if (node->index >= (ngx_int_t)r->ncaptures)
return NGX_ERROR;
cap = r->captures;
ncap = node->index * 2;
value->data = r->captures_data + cap[ncap];
value->len = cap[ncap + 1] - cap[ncap];
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"let getting capture %d: '%*s'", node->index, value->len, value->data);
break;
case NGX_LTYPE_LITERAL:
*value = node->name;
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"let getting literal: '%*s'", value->len, value->data);
break;
case NGX_LTYPE_FUNCTION:
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"let calling function '%*s'; argc: %d",
node->name.len, node->name.data, node->args.nelts);
/* parse arguments */
ngx_array_init(&args, r->pool, node->args.nelts, sizeof(ngx_str_t));
astr = ngx_array_push_n(&args, node->args.nelts);
anode = node->args.elts;
for(n = 0; n < node->args.nelts; ++n) {
ret = ngx_let_get_node_value(r, *anode++, astr++);
if (ret != NGX_OK)
return ret;
}
ret = ngx_let_call_fun(r, &node->name, &args, value);
if (ret != NGX_OK)
return ret;
break;
case NGX_LTYPE_OPERATION:
ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"let applying operation '%c'; argc: %d", node->index, node->args.nelts);
/* parse arguments */
ngx_array_init(&args, r->pool, node->args.nelts, sizeof(ngx_str_t));
astr = ngx_array_push_n(&args, node->args.nelts);
anode = node->args.elts;
for(n = 0; n < node->args.nelts; ++n) {
ret = ngx_let_get_node_value(r, *anode++, astr++);
if (ret != NGX_OK)
return ret;
}
if (strchr("+-*/%&|", node->index)) {
/* binary integer operation */
ret = ngx_let_apply_binary_integer_op(r, node->index, &args, value);
if (ret != NGX_OK)
return ret;
} else if (node->index == '.') {
/* string concatenation */
value->len = 0;
astr = args.elts;
for(n = 0; n < args.nelts; ++n, ++astr)
value->len += astr->len;
value->data = ngx_palloc(r->pool, value->len);
astr = args.elts;
s = value->data;
for(n = 0, s = value->data; n < args.nelts; ++n, s += astr++->len)
memcpy(s, astr->data, astr->len);
ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"let %d strings concatenated '%*s'", args.nelts, value->len, value->data);
}
break;
}
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_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;
}
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_stream_core_listen(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_stream_core_srv_conf_t *cscf = conf;
ngx_str_t *value, size;
ngx_url_t u;
ngx_uint_t i, n, backlog;
ngx_stream_listen_t *ls, *als;
ngx_stream_core_main_conf_t *cmcf;
cscf->listen = 1;
value = cf->args->elts;
ngx_memzero(&u, sizeof(ngx_url_t));
u.url = value[1];
u.listen = 1;
if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
if (u.err) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"%s in \"%V\" of the \"listen\" directive",
u.err, &u.url);
}
return NGX_CONF_ERROR;
}
cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);
ls = ngx_array_push_n(&cmcf->listen, u.naddrs);
if (ls == NULL) {
return NGX_CONF_ERROR;
}
ngx_memzero(ls, sizeof(ngx_stream_listen_t));
ls->backlog = NGX_LISTEN_BACKLOG;
ls->rcvbuf = -1;
ls->sndbuf = -1;
ls->type = SOCK_STREAM;
ls->ctx = cf->ctx;
#if (NGX_HAVE_INET6)
ls->ipv6only = 1;
#endif
backlog = 0;
for (i = 2; i < cf->args->nelts; i++) {
#if !(NGX_WIN32)
if (ngx_strcmp(value[i].data, "udp") == 0) {
ls->type = SOCK_DGRAM;
continue;
}
#endif
if (ngx_strcmp(value[i].data, "bind") == 0) {
ls->bind = 1;
continue;
}
if (ngx_strncmp(value[i].data, "backlog=", 8) == 0) {
ls->backlog = ngx_atoi(value[i].data + 8, value[i].len - 8);
ls->bind = 1;
if (ls->backlog == NGX_ERROR || ls->backlog == 0) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid backlog \"%V\"", &value[i]);
return NGX_CONF_ERROR;
}
backlog = 1;
continue;
}
if (ngx_strncmp(value[i].data, "rcvbuf=", 7) == 0) {
size.len = value[i].len - 7;
size.data = value[i].data + 7;
ls->rcvbuf = ngx_parse_size(&size);
ls->bind = 1;
if (ls->rcvbuf == NGX_ERROR) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid rcvbuf \"%V\"", &value[i]);
return NGX_CONF_ERROR;
}
continue;
}
if (ngx_strncmp(value[i].data, "sndbuf=", 7) == 0) {
size.len = value[i].len - 7;
size.data = value[i].data + 7;
ls->sndbuf = ngx_parse_size(&size);
ls->bind = 1;
if (ls->sndbuf == NGX_ERROR) {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid sndbuf \"%V\"", &value[i]);
return NGX_CONF_ERROR;
}
continue;
}
if (ngx_strncmp(value[i].data, "ipv6only=o", 10) == 0) {
#if (NGX_HAVE_INET6 && defined IPV6_V6ONLY)
if (ngx_strcmp(&value[i].data[10], "n") == 0) {
ls->ipv6only = 1;
} else if (ngx_strcmp(&value[i].data[10], "ff") == 0) {
ls->ipv6only = 0;
} else {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid ipv6only flags \"%s\"",
&value[i].data[9]);
return NGX_CONF_ERROR;
}
ls->bind = 1;
continue;
#else
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"bind ipv6only is not supported "
"on this platform");
return NGX_CONF_ERROR;
#endif
}
if (ngx_strcmp(value[i].data, "reuseport") == 0) {
#if (NGX_HAVE_REUSEPORT)
ls->reuseport = 1;
ls->bind = 1;
#else
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"reuseport is not supported "
"on this platform, ignored");
#endif
continue;
}
if (ngx_strcmp(value[i].data, "ssl") == 0) {
#if (NGX_STREAM_SSL)
ngx_stream_ssl_conf_t *sslcf;
sslcf = ngx_stream_conf_get_module_srv_conf(cf,
ngx_stream_ssl_module);
sslcf->listen = 1;
sslcf->file = cf->conf_file->file.name.data;
sslcf->line = cf->conf_file->line;
ls->ssl = 1;
continue;
#else
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"the \"ssl\" parameter requires "
"ngx_stream_ssl_module");
return NGX_CONF_ERROR;
#endif
}
if (ngx_strncmp(value[i].data, "so_keepalive=", 13) == 0) {
if (ngx_strcmp(&value[i].data[13], "on") == 0) {
ls->so_keepalive = 1;
} else if (ngx_strcmp(&value[i].data[13], "off") == 0) {
ls->so_keepalive = 2;
} else {
#if (NGX_HAVE_KEEPALIVE_TUNABLE)
u_char *p, *end;
ngx_str_t s;
end = value[i].data + value[i].len;
s.data = value[i].data + 13;
p = ngx_strlchr(s.data, end, ':');
if (p == NULL) {
p = end;
}
if (p > s.data) {
s.len = p - s.data;
ls->tcp_keepidle = ngx_parse_time(&s, 1);
if (ls->tcp_keepidle == (time_t) NGX_ERROR) {
goto invalid_so_keepalive;
}
}
s.data = (p < end) ? (p + 1) : end;
p = ngx_strlchr(s.data, end, ':');
if (p == NULL) {
p = end;
}
if (p > s.data) {
s.len = p - s.data;
ls->tcp_keepintvl = ngx_parse_time(&s, 1);
if (ls->tcp_keepintvl == (time_t) NGX_ERROR) {
goto invalid_so_keepalive;
}
}
s.data = (p < end) ? (p + 1) : end;
if (s.data < end) {
s.len = end - s.data;
ls->tcp_keepcnt = ngx_atoi(s.data, s.len);
if (ls->tcp_keepcnt == NGX_ERROR) {
goto invalid_so_keepalive;
}
}
if (ls->tcp_keepidle == 0 && ls->tcp_keepintvl == 0
&& ls->tcp_keepcnt == 0)
{
goto invalid_so_keepalive;
}
ls->so_keepalive = 1;
#else
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"the \"so_keepalive\" parameter accepts "
"only \"on\" or \"off\" on this platform");
return NGX_CONF_ERROR;
#endif
}
ls->bind = 1;
continue;
#if (NGX_HAVE_KEEPALIVE_TUNABLE)
invalid_so_keepalive:
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid so_keepalive value: \"%s\"",
&value[i].data[13]);
return NGX_CONF_ERROR;
#endif
}
if (ngx_strcmp(value[i].data, "proxy_protocol") == 0) {
ls->proxy_protocol = 1;
continue;
}
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"the invalid \"%V\" parameter", &value[i]);
return NGX_CONF_ERROR;
}
if (ls->type == SOCK_DGRAM) {
if (backlog) {
return "\"backlog\" parameter is incompatible with \"udp\"";
}
#if (NGX_STREAM_SSL)
if (ls->ssl) {
return "\"ssl\" parameter is incompatible with \"udp\"";
}
#endif
if (ls->so_keepalive) {
return "\"so_keepalive\" parameter is incompatible with \"udp\"";
}
if (ls->proxy_protocol) {
return "\"proxy_protocol\" parameter is incompatible with \"udp\"";
}
}
als = cmcf->listen.elts;
for (n = 0; n < u.naddrs; n++) {
ls[n] = ls[0];
ls[n].sockaddr = u.addrs[n].sockaddr;
ls[n].socklen = u.addrs[n].socklen;
ls[n].addr_text = u.addrs[n].name;
ls[n].wildcard = ngx_inet_wildcard(ls[n].sockaddr);
for (i = 0; i < cmcf->listen.nelts - u.naddrs + n; i++) {
if (ls[n].type != als[i].type) {
continue;
}
if (ngx_cmp_sockaddr(als[i].sockaddr, als[i].socklen,
ls[n].sockaddr, ls[n].socklen, 1)
!= NGX_OK)
{
continue;
}
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"duplicate \"%V\" address and port pair",
&ls[n].addr_text);
return NGX_CONF_ERROR;
}
}
return NGX_CONF_OK;
}
static void *
ngx_http_replace_script_add_code(ngx_array_t *codes, size_t size)
{
return ngx_array_push_n(codes, size);
}
static void
ngx_http_graphicsmagick_command_handler(ngx_http_request_t *r)
{
ngx_str_t *source;
ngx_str_t *dest;
ngx_str_t *ai;
ngx_str_t *cmd;
ngx_str_t *uri;
ngx_array_t *tokens;
ngx_int_t rc;
ngx_uint_t i;
ngx_log_t *log;
ngx_buf_t *b;
ngx_chain_t out;
ngx_fd_t fd;
ngx_open_file_info_t of;
ngx_http_core_loc_conf_t *clcf;
size_t argc;
char **argv;
u_char *cp;
u_char *last;
size_t root;
ngx_temp_file_t *tf;
unsigned int status;
log = r->connection->log;
tokens = ngx_array_create(r->pool, 10, sizeof(ngx_str_t));
if (tokens == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
ai = ngx_array_push(tokens);
if (ai == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
ai->data = (u_char *) "convert";
ai->len = 7;
// get command from HTTP headers or queryString
cmd = ngx_http_graphicsmagick_get_command(r);
if (cmd == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
ngx_log_error(NGX_LOG_ERR, log, 0, "graphicsmagick convert command: \"%s\"", cmd->data);
//ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
// "graphicsmagick convert command: \"%s\"", cmd->data);
clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
if (r->method & NGX_HTTP_POST) {
source = dest = &r->request_body->temp_file->file.name;
} else {
uri = ngx_pcalloc(r->pool, sizeof(ngx_str_t));
source = ngx_pcalloc(r->pool, sizeof(ngx_str_t));
cp = cmd->data;
while (cp < cmd->data + cmd->len) {
if (*cp == ' ') {
uri->data = cmd->data;
uri->len = cp - cmd->data;
cmd->data = cp + 1;
cmd->len = cmd->len - uri->len - 1;
break;
}
cp++;
}
if (uri->len == 0) {
ngx_http_graphicsmagick_server_error(r);
return;
}
last = ngx_http_graphicsmagickd_map_uri_to_path(r, uri, source, &root, 0);
if (last == NULL) {
ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
return;
}
source->len = last - source->data;
tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
if (tf == NULL) {
ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
return;
}
tf->file.fd = NGX_INVALID_FILE;
tf->file.log = r->connection->log;
tf->path = clcf->client_body_temp_path;
tf->pool = r->pool;
tf->log_level = r->request_body_file_log_level;
tf->persistent = r->request_body_in_persistent_file;
tf->clean = 1;
if (r->request_body_file_group_access) {
tf->access = 0660;
}
if (ngx_create_temp_file(&tf->file, tf->path, tf->pool,
tf->persistent, tf->clean, tf->access)
!= NGX_OK)
{
ngx_http_graphicsmagick_server_error(r);
return;
}
dest = &tf->file.name;
}
// push source file name into tokens
ai = ngx_array_push(tokens);
if (ai == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
*ai = *source;
// tokenize command, and push them into tokens array
rc = ngx_http_graphicsmagick_tokenize_command(r, cmd, tokens);
if (rc == NGX_ERROR) {
ngx_http_graphicsmagick_server_error(r);
return;
}
ai = ngx_array_push_n(tokens, 2);
if (ai == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
ai->data = (u_char *) "-compress";
ai->len = 9;
ai++;
ai->data = (u_char *) "JPEG";
ai->len = 4;
// push dest filename into tokens again, to save generated thumbnail into dest file
ai = ngx_array_push(tokens);
if (ai == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
*ai = *dest;
// OK, prepare convert args
argc = tokens->nelts;
argv = ngx_palloc(r->pool, argc * sizeof(char*));
if (argv == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
ai = tokens->elts;
for (i = 0; i < argc; i++) {
argv[i] = (char *) ai[i].data;
ngx_log_error(NGX_LOG_ERR, log, 0, "current[%d]: %s", i, argv[i]);
}
ngx_array_destroy(tokens);
// DO graphicsmagick converting
status = ngx_http_graphicsmagick_convert(argv, argc);
if (status == 0) {
ngx_http_graphicsmagick_server_error(r);
return;
}
// Done, write response
of.test_dir = 0;
//of.retest = clcf->open_file_cache_retest;
of.errors = clcf->open_file_cache_errors;
of.events = clcf->open_file_cache_events;
rc = ngx_open_cached_file(clcf->open_file_cache, dest, &of, r->pool);
if (rc == NGX_ERROR) {
ngx_log_error(NGX_LOG_ERR, log, of.err,
"failed to open file \"%s\"", dest->data);
ngx_http_graphicsmagick_server_error(r);
return;
}
fd = of.fd;
log->action = "sending response to client";
r->headers_out.status = NGX_HTTP_OK;
r->headers_out.content_type.len = sizeof("image/jpeg") - 1;
r->headers_out.content_type.data = (u_char *) "image/jpeg";
r->headers_out.content_length_n = of.size;
r->headers_out.last_modified_time = of.mtime;
if (r != r->main && of.size == 0) {
rc = ngx_http_send_header(r);
ngx_http_finalize_request(r, rc);
return;
}
b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
if (b == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
if (b->file == NULL) {
ngx_http_graphicsmagick_server_error(r);
return;
}
rc = ngx_http_send_header(r);
b->file_pos = 0;
b->file_last = of.size;
b->in_file = b->file_last ? 1: 0;
b->last_buf = (r == r->main) ? 1: 0;
b->last_in_chain = 1;
b->file->fd = fd;
b->file->name = *dest;
b->file->log = log;
out.buf = b;
out.next = NULL;
rc = ngx_http_output_filter(r, &out);
ngx_http_finalize_request(r, rc);
return;
}
static jlong JNICALL jni_ngx_array_push_n(JNIEnv *env, jclass cls, jlong array, jlong n) {
return (uintptr_t)ngx_array_push_n((ngx_array_t *)array, (ngx_uint_t)n);
}
static void *
ngx_stream_lua_script_add_code(ngx_array_t *codes, size_t size)
{
return ngx_array_push_n(codes, size);
}
