mirror/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2024-12-15 21:39:00 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
f3a7b14931
nginx/src/core/ngx_conf_file.c
Igor Sysoev e5a222c6fe nginx-0.1.16-RELEASE import 
*) Bugfix: if the response were transferred by chunks, then on the HEAD
       request the final chunk was issued.

    *) Bugfix: the "Connection: keep-alive" header were issued, even if the
       keepalive_timeout directive forbade the keep-alive use.

    *) Bugfix: the errors in the ngx_http_fastcgi_module caused the
       segmentation faults.

    *) Bugfix: the compressed response encrypted by SSL may not transferred
       complete.

    *) Bugfix: the TCP-specific TCP_NODELAY, TCP_NOPSUH, and TCP_CORK
       options, are not used for the unix domain sockets.

    *) Feature: the rewrite directive supports the arguments rewriting.

    *) Bugfix: the response code 400 was returned for the POST request with
       the "Content-Length: 0" header; the bug had appeared in 0.1.14.
2005-01-25 12:27:35 +00:00

1057 lines
26 KiB
C
Raw Blame History

/*
* Copyright (C) Igor Sysoev
*/
#include <ngx_config.h>
#include <ngx_core.h>
static char *ngx_conf_include(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static ngx_command_t ngx_conf_commands[] = {
{ ngx_string("include"),
NGX_ANY_CONF|NGX_CONF_TAKE1,
ngx_conf_include,
0,
0,
NULL },
ngx_null_command
};
ngx_module_t ngx_conf_module = {
NGX_MODULE,
NULL, /* module context */
ngx_conf_commands, /* module directives */
NGX_CONF_MODULE, /* module type */
NULL, /* init module */
NULL /* init child */
};
/* The ten fixed arguments */
static int argument_number[] = {
NGX_CONF_NOARGS,
NGX_CONF_TAKE1,
NGX_CONF_TAKE2,
NGX_CONF_TAKE3,
NGX_CONF_TAKE4,
NGX_CONF_TAKE5,
NGX_CONF_TAKE6,
NGX_CONF_TAKE7
};
static int ngx_conf_read_token(ngx_conf_t *cf);
char *ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
{
int m, rc, found, valid;
char *rv;
void *conf, **confp;
ngx_fd_t fd;
ngx_str_t *name;
ngx_conf_file_t *prev;
ngx_command_t *cmd;
#if (NGX_SUPPRESS_WARN)
fd = NGX_INVALID_FILE;
prev = NULL;
#endif
if (filename) {
/* open configuration file */
fd = ngx_open_file(filename->data, NGX_FILE_RDONLY, NGX_FILE_OPEN);
if (fd == NGX_INVALID_FILE) {
ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
ngx_open_file_n " \"%s\" failed", filename->data);
return NGX_CONF_ERROR;
}
prev = cf->conf_file;
if (!(cf->conf_file = ngx_palloc(cf->pool, sizeof(ngx_conf_file_t)))) {
return NGX_CONF_ERROR;
}
if (ngx_fd_info(fd, &cf->conf_file->file.info) == -1) {
ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
ngx_fd_info_n " \"%s\" failed", filename->data);
}
if (!(cf->conf_file->buffer = ngx_create_temp_buf(cf->pool, 1024))) {
return NGX_CONF_ERROR;
}
cf->conf_file->file.fd = fd;
cf->conf_file->file.name.len = filename->len;
cf->conf_file->file.name.data = filename->data;
cf->conf_file->file.offset = 0;
cf->conf_file->file.log = cf->log;;
cf->conf_file->line = 1;
}
for ( ;; ) {
rc = ngx_conf_read_token(cf);
/*
* ngx_conf_read_token() may return
* NGX_ERROR there is error
* NGX_OK the token terminated by ";" was found
* NGX_CONF_BLOCK_START the token terminated by "{" was found
* NGX_CONF_BLOCK_DONE the "}" was found
* NGX_CONF_FILE_DONE the configuration file is done
*/
if (rc == NGX_ERROR) {
break;
}
if (rc != NGX_OK && rc != NGX_CONF_BLOCK_START) {
break;
}
if (cf->handler) {
/*
* the custom handler, i.e., that is used in the http's
* "types { ... }" directive
*/
rv = (*cf->handler)(cf, NULL, cf->handler_conf);
if (rv == NGX_CONF_OK) {
continue;
} else if (rv == NGX_CONF_ERROR) {
rc = NGX_ERROR;
break;
} else {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"%s in %s:%d",
rv,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
}
name = (ngx_str_t *) cf->args->elts;
found = 0;
for (m = 0; rc != NGX_ERROR && !found && ngx_modules[m]; m++) {
/* look up the directive in the appropriate modules */
if (ngx_modules[m]->type != NGX_CONF_MODULE
&& ngx_modules[m]->type != cf->module_type)
{
continue;
}
cmd = ngx_modules[m]->commands;
if (cmd == NULL) {
continue;
}
while (cmd->name.len) {
if (name->len == cmd->name.len
&& ngx_strcmp(name->data, cmd->name.data) == 0)
{
found = 1;
/* is the directive's location right ? */
if ((cmd->type & cf->cmd_type) == 0) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"directive \"%s\" in %s:%d "
"is not allowed here",
name->data,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
if (!(cmd->type & NGX_CONF_BLOCK) && rc != NGX_OK)
{
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"directive \"%s\" in %s:%d "
"is not terminated by \";\"",
name->data,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
if ((cmd->type & NGX_CONF_BLOCK)
&& rc != NGX_CONF_BLOCK_START)
{
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"directive \"%s\" in %s:%d "
"has not the opening \"{\"",
name->data,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
/* is the directive's argument count right ? */
if (cmd->type & NGX_CONF_ANY) {
valid = 1;
} else if (cmd->type & NGX_CONF_FLAG) {
if (cf->args->nelts == 2) {
valid = 1;
} else {
valid = 0;
}
} else if (cmd->type & NGX_CONF_1MORE) {
if (cf->args->nelts > 1) {
valid = 1;
} else {
valid = 0;
}
} else if (cmd->type & NGX_CONF_2MORE) {
if (cf->args->nelts > 2) {
valid = 1;
} else {
valid = 0;
}
} else if (cf->args->nelts <= 10
&& (cmd->type
& argument_number[cf->args->nelts - 1]))
{
valid = 1;
} else {
valid = 0;
}
if (!valid) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"invalid number arguments in "
"directive \"%s\" in %s:%d",
name->data,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
/* set up the directive's configuration context */
conf = NULL;
if (cmd->type & NGX_DIRECT_CONF) {
conf = ((void **) cf->ctx)[ngx_modules[m]->index];
} else if (cmd->type & NGX_MAIN_CONF) {
conf = &(((void **) cf->ctx)[ngx_modules[m]->index]);
} else if (cf->ctx) {
confp = *(void **) ((char *) cf->ctx + cmd->conf);
if (confp) {
conf = confp[ngx_modules[m]->ctx_index];
}
}
rv = cmd->set(cf, cmd, conf);
if (rv == NGX_CONF_OK) {
break;
} else if (rv == NGX_CONF_ERROR) {
rc = NGX_ERROR;
break;
} else {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"the \"%s\" directive %s in %s:%d",
name->data, rv,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
}
cmd++;
}
}
if (!found) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"unknown directive \"%s\" in %s:%d",
name->data,
cf->conf_file->file.name.data,
cf->conf_file->line);
rc = NGX_ERROR;
break;
}
if (rc == NGX_ERROR) {
break;
}
}
if (filename) {
cf->conf_file = prev;
if (ngx_close_file(fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
ngx_close_file_n " %s failed",
cf->conf_file->file.name.data);
return NGX_CONF_ERROR;
}
}
if (rc == NGX_ERROR) {
return NGX_CONF_ERROR;
}
return NGX_CONF_OK;
}
static int ngx_conf_read_token(ngx_conf_t *cf)
{
u_char *start, ch, *src, *dst;
int len;
int found, need_space, last_space, sharp_comment;
int quoted, s_quoted, d_quoted;
ssize_t n;
ngx_str_t *word;
ngx_buf_t *b;
found = 0;
need_space = 0;
last_space = 1;
sharp_comment = 0;
quoted = s_quoted = d_quoted = 0;
cf->args->nelts = 0;
b = cf->conf_file->buffer;
start = b->pos;
for ( ;; ) {
if (b->pos >= b->last) {
if (cf->conf_file->file.offset
>= ngx_file_size(&cf->conf_file->file.info)) {
return NGX_CONF_FILE_DONE;
}
if (b->pos - start) {
ngx_memcpy(b->start, start, b->pos - start);
}
n = ngx_read_file(&cf->conf_file->file,
b->start + (b->pos - start),
b->end - (b->start + (b->pos - start)),
cf->conf_file->file.offset);
if (n == NGX_ERROR) {
return NGX_ERROR;
}
b->pos = b->start + (b->pos - start);
start = b->start;
b->last = b->pos + n;
}
ch = *b->pos++;
if (ch == LF) {
cf->conf_file->line++;
if (sharp_comment) {
sharp_comment = 0;
}
}
if (sharp_comment) {
continue;
}
if (quoted) {
quoted = 0;
continue;
}
if (need_space) {
if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
last_space = 1;
need_space = 0;
continue;
}
if (ch == ';') {
return NGX_OK;
}
if (ch == '{') {
return NGX_CONF_BLOCK_START;
}
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"unexpected '%c' in %s:%d",
ch, cf->conf_file->file.name.data,
cf->conf_file->line);
return NGX_ERROR;
}
if (last_space) {
if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
continue;
}
start = b->pos - 1;
switch (ch) {
case ';':
case '{':
if (cf->args->nelts == 0) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"unexpected '%c' in %s:%d",
ch, cf->conf_file->file.name.data,
cf->conf_file->line);
return NGX_ERROR;
}
if (ch == '{') {
return NGX_CONF_BLOCK_START;
}
return NGX_OK;
case '}':
if (cf->args->nelts > 0) {
ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
"unexpected '}' in %s:%d",
cf->conf_file->file.name.data,
cf->conf_file->line);
return NGX_ERROR;
}
return NGX_CONF_BLOCK_DONE;
case '#':
sharp_comment = 1;
continue;
case '\\':
quoted = 1;
last_space = 0;
continue;
case '"':
start++;
d_quoted = 1;
last_space = 0;
continue;
case '\'':
start++;
s_quoted = 1;
last_space = 0;
continue;
default:
last_space = 0;
}
} else {
if (ch == '\\') {
quoted = 1;
continue;
}
if (d_quoted) {
if (ch == '"') {
d_quoted = 0;
need_space = 1;
found = 1;
}
} else if (s_quoted) {
if (ch == '\'') {
s_quoted = 0;
need_space = 1;
found = 1;
}
} else if (ch == ' ' || ch == '\t' || ch == CR || ch == LF
|| ch == ';' || ch == '{') {
last_space = 1;
found = 1;
}
if (found) {
if (!(word = ngx_push_array(cf->args))) {
return NGX_ERROR;
}
if (!(word->data = ngx_palloc(cf->pool, b->pos - start + 1))) {
return NGX_ERROR;
}
for (dst = word->data, src = start, len = 0;
src < b->pos - 1;
len++)
{
if (*src == '\\') {
switch (src[1]) {
case '"':
case '\'':
case '\\':
src++;
break;
case 't':
*dst++ = '\t';
src += 2;
continue;
case 'r':
*dst++ = '\r';
src += 2;
continue;
case 'n':
*dst++ = '\n';
src += 2;
continue;
}
}
*dst++ = *src++;
}
*dst = '\0';
word->len = len;
if (ch == ';') {
return NGX_OK;
}
if (ch == '{') {
return NGX_CONF_BLOCK_START;
}
found = 0;
}
}
}
}
static char *ngx_conf_include(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_str_t *value, file;
value = cf->args->elts;
file = value[1];
if (ngx_conf_full_name(cf->cycle, &file) == NGX_ERROR){
return NGX_CONF_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
return ngx_conf_parse(cf, &file);
}
ngx_int_t ngx_conf_full_name(ngx_cycle_t *cycle, ngx_str_t *name)
{
u_char *p;
ngx_str_t old;
if (name->data[0] == '/') {
return NGX_OK;
}
#if (NGX_WIN32)
if (name->len > 2
&& name->data[1] == ':'
&& ((name->data[0] >= 'a' && name->data[0] <= 'z')
|| (name->data[0] >= 'A' && name->data[0] <= 'Z')))
{
return NGX_OK;
}
#endif
old = *name;
name->len = cycle->root.len + old.len;
if (cycle->connections) {
if (!(name->data = ngx_palloc(cycle->pool, name->len + 1))) {
return NGX_ERROR;
}
} else {
/* the init_cycle */
if (!(name->data = ngx_alloc(name->len + 1, cycle->log))) {
return NGX_ERROR;
}
}
p = ngx_cpymem(name->data, cycle->root.data, cycle->root.len),
ngx_cpystrn(p, old.data, old.len + 1);
return NGX_OK;
}
ngx_open_file_t *ngx_conf_open_file(ngx_cycle_t *cycle, ngx_str_t *name)
{
ngx_str_t full;
ngx_uint_t i;
ngx_list_part_t *part;
ngx_open_file_t *file;
#if (NGX_SUPPRESS_WARN)
full.len = 0;
full.data = NULL;
#endif
if (name) {
full = *name;
if (ngx_conf_full_name(cycle, &full) == NGX_ERROR) {
return NULL;
}
part = &cycle->open_files.part;
file = part->elts;
for (i = 0; /* void */ ; i++) {
if (i >= part->nelts) {
if (part->next == NULL) {
break;
}
part = part->next;
file = part->elts;
i = 0;
}
if (full.len != file[i].name.len) {
continue;
}
if (ngx_strcmp(full.data, file[i].name.data) == 0) {
return &file[i];
}
}
}
if (!(file = ngx_list_push(&cycle->open_files))) {
return NULL;
}
if (name) {
file->fd = NGX_INVALID_FILE;
file->name = full;
} else {
file->fd = ngx_stderr_fileno;
file->name.len = 0;
file->name.data = NULL;
}
return file;
}
void ngx_conf_log_error(ngx_uint_t level, ngx_conf_t *cf, ngx_err_t err,
char *fmt, ...)
{
u_char errstr[NGX_MAX_CONF_ERRSTR], *buf, *last;
va_list args;
last = errstr + NGX_MAX_CONF_ERRSTR;
va_start(args, fmt);
buf = ngx_vsnprintf(errstr, last - errstr, fmt, args);
va_end(args);
*buf = '\0';
if (err) {
buf = ngx_snprintf(buf, last - buf - 1, " (%d: ", err);
buf = ngx_strerror_r(err, buf, last - buf - 1);
*buf++ = ')';
*buf = '\0';
}
ngx_log_error(level, cf->log, 0, "%s in %s:%d",
errstr, cf->conf_file->file.name.data, cf->conf_file->line);
}
char *ngx_conf_set_flag_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_str_t *value;
ngx_flag_t *fp;
ngx_conf_post_t *post;
fp = (ngx_flag_t *) (p + cmd->offset);
if (*fp != NGX_CONF_UNSET) {
return "is duplicate";
}
value = cf->args->elts;
if (ngx_strcasecmp(value[1].data, "on") == 0) {
*fp = 1;
} else if (ngx_strcasecmp(value[1].data, "off") == 0) {
*fp = 0;
} else {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid value \"%s\" in \"%s\" directive, "
"it must be \"on\" or \"off\"",
value[1].data, cmd->name.data);
return NGX_CONF_ERROR;
}
if (cmd->post) {
post = cmd->post;
return post->post_handler(cf, post, fp);
}
return NGX_CONF_OK;
}
char *ngx_conf_set_str_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_str_t *field, *value;
ngx_conf_post_t *post;
field = (ngx_str_t *) (p + cmd->offset);
if (field->data) {
return "is duplicate";
}
value = cf->args->elts;
*field = value[1];
if (cmd->post) {
post = cmd->post;
return post->post_handler(cf, post, field);
}
return NGX_CONF_OK;
}
char *ngx_conf_set_num_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_int_t *np;
ngx_str_t *value;
ngx_conf_post_t *post;
np = (ngx_int_t *) (p + cmd->offset);
if (*np != NGX_CONF_UNSET) {
return "is duplicate";
}
value = cf->args->elts;
*np = ngx_atoi(value[1].data, value[1].len);
if (*np == NGX_ERROR) {
return "invalid number";
}
if (cmd->post) {
post = cmd->post;
return post->post_handler(cf, post, np);
}
return NGX_CONF_OK;
}
char *ngx_conf_set_size_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
size_t *sp;
ngx_str_t *value;
ngx_conf_post_t *post;
sp = (size_t *) (p + cmd->offset);
if (*sp != NGX_CONF_UNSET_SIZE) {
return "is duplicate";
}
value = cf->args->elts;
*sp = ngx_parse_size(&value[1]);
if (*sp == (size_t) NGX_ERROR) {
return "invalid value";
}
if (cmd->post) {
post = cmd->post;
return post->post_handler(cf, post, sp);
}
return NGX_CONF_OK;
}
char *ngx_conf_set_msec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_msec_t *msp;
ngx_str_t *value;
ngx_conf_post_t *post;
msp = (ngx_msec_t *) (p + cmd->offset);
if (*msp != NGX_CONF_UNSET_MSEC) {
return "is duplicate";
}
value = cf->args->elts;
*msp = ngx_parse_time(&value[1], 0);
if (*msp == (ngx_msec_t) NGX_ERROR) {
return "invalid value";
}
if (*msp == (ngx_msec_t) NGX_PARSE_LARGE_TIME) {
return "value must be less than 597 hours";
}
if (cmd->post) {
post = cmd->post;
return post->post_handler(cf, post, msp);
}
return NGX_CONF_OK;
}
char *ngx_conf_set_sec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
time_t *sp;
ngx_str_t *value;
ngx_conf_post_t *post;
sp = (time_t *) (p + cmd->offset);
if (*sp != NGX_CONF_UNSET) {
return "is duplicate";
}
value = cf->args->elts;
*sp = ngx_parse_time(&value[1], 1);
if (*sp == NGX_ERROR) {
return "invalid value";
}
if (*sp == NGX_PARSE_LARGE_TIME) {
return "value must be less than 68 years";
}
if (cmd->post) {
post = cmd->post;
return post->post_handler(cf, post, sp);
}
return NGX_CONF_OK;
}
char *ngx_conf_set_bufs_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_str_t *value;
ngx_bufs_t *bufs;
bufs = (ngx_bufs_t *) (p + cmd->offset);
if (bufs->num) {
return "is duplicate";
}
value = cf->args->elts;
bufs->num = ngx_atoi(value[1].data, value[1].len);
if (bufs->num == NGX_ERROR || bufs->num == 0) {
return "invalid value";
}
bufs->size = ngx_parse_size(&value[2]);
if (bufs->size == (size_t) NGX_ERROR || bufs->size == 0) {
return "invalid value";
}
return NGX_CONF_OK;
}
char *ngx_conf_set_enum_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_uint_t *np, i;
ngx_str_t *value;
ngx_conf_enum_t *e;
np = (ngx_uint_t *) (p + cmd->offset);
if (*np != NGX_CONF_UNSET_UINT) {
return "is duplicate";
}
value = cf->args->elts;
e = cmd->post;
for (i = 0; e[i].name.len != 0; i++) {
if (e[i].name.len != value[1].len
|| ngx_strcasecmp(e[i].name.data, value[1].data) != 0)
{
continue;
}
*np = e[i].value;
return NGX_CONF_OK;
}
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
"invalid value \"%s\"", value[1].data);
return NGX_CONF_ERROR;
}
char *ngx_conf_set_bitmask_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *p = conf;
ngx_uint_t *np, i, m;
ngx_str_t *value;
ngx_conf_bitmask_t *mask;
np = (ngx_uint_t *) (p + cmd->offset);
value = cf->args->elts;
mask = cmd->post;
for (i = 1; i < cf->args->nelts; i++) {
for (m = 0; mask[m].name.len != 0; m++) {
if (mask[m].name.len != value[i].len
|| ngx_strcasecmp(mask[m].name.data, value[i].data) != 0)
{
continue;
}
if (*np & mask[m].mask) {
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
"duplicate value \"%s\"", value[i].data);
} else {
*np |= mask[m].mask;
}
break;
}
if (mask[m].name.len == 0) {
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
"invalid value \"%s\"", value[i].data);
return NGX_CONF_ERROR;
}
}
return NGX_CONF_OK;
}
char *ngx_conf_unsupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
return "unsupported on this platform";
}
char *ngx_conf_check_num_bounds(ngx_conf_t *cf, void *post, void *data)
{
ngx_conf_num_bounds_t *bounds = post;
ngx_int_t *np = data;
if (bounds->high == -1) {
if (*np >= bounds->low) {
return NGX_CONF_OK;
}
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"value must be equal or more than %d", bounds->low);
return NGX_CONF_ERROR;
}
if (*np >= bounds->low && *np <= bounds->high) {
return NGX_CONF_OK;
}
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"value must be between %d and %d",
bounds->low, bounds->high);
return NGX_CONF_ERROR;
}
Reference in New Issue View Git Blame Copy Permalink