Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_conf_file.c
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) Igor Sysoev
4  * Copyright (C) Nginx, Inc.
5  */
6 
7 
8 #include <ngx_config.h>
9 #include <ngx_core.h>
10 
11 #define NGX_CONF_BUFFER 4096
12 
13 static ngx_int_t ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last);
14 static ngx_int_t ngx_conf_read_token(ngx_conf_t *cf);
15 static ngx_int_t ngx_conf_test_full_name(ngx_str_t *name);
16 static void ngx_conf_flush_files(ngx_cycle_t *cycle);
17 
18 
19 static ngx_command_t ngx_conf_commands[] = {
20 
21  { ngx_string("include"),
22  NGX_ANY_CONF|NGX_CONF_TAKE1,
23  ngx_conf_include,
24  0,
25  0,
26  NULL },
27 
28  ngx_null_command
29 };
30 
31 
32 ngx_module_t ngx_conf_module = {
33  NGX_MODULE_V1,
34  NULL, /* module context */
35  ngx_conf_commands, /* module directives */
36  NGX_CONF_MODULE, /* module type */
37  NULL, /* init master */
38  NULL, /* init module */
39  NULL, /* init process */
40  NULL, /* init thread */
41  NULL, /* exit thread */
42  ngx_conf_flush_files, /* exit process */
43  NULL, /* exit master */
44  NGX_MODULE_V1_PADDING
45 };
46 
47 
48 /* The eight fixed arguments */
49 
50 static ngx_uint_t argument_number[] = {
51  NGX_CONF_NOARGS,
52  NGX_CONF_TAKE1,
53  NGX_CONF_TAKE2,
54  NGX_CONF_TAKE3,
55  NGX_CONF_TAKE4,
56  NGX_CONF_TAKE5,
57  NGX_CONF_TAKE6,
58  NGX_CONF_TAKE7
59 };
60 
61 
62 char *
63 ngx_conf_param(ngx_conf_t *cf)
64 {
65  char *rv;
66  ngx_str_t *param;
67  ngx_buf_t b;
68  ngx_conf_file_t conf_file;
69 
70  param = &cf->cycle->conf_param;
71 
72  if (param->len == 0) {
73  return NGX_CONF_OK;
74  }
75 
76  ngx_memzero(&conf_file, sizeof(ngx_conf_file_t));
77 
78  ngx_memzero(&b, sizeof(ngx_buf_t));
79 
80  b.start = param->data;
81  b.pos = param->data;
82  b.last = param->data + param->len;
83  b.end = b.last;
84  b.temporary = 1;
85 
86  conf_file.file.fd = NGX_INVALID_FILE;
87  conf_file.file.name.data = NULL;
88  conf_file.line = 0;
89 
90  cf->conf_file = &conf_file;
91  cf->conf_file->buffer = &b;
92 
93  rv = ngx_conf_parse(cf, NULL);
94 
95  cf->conf_file = NULL;
96 
97  return rv;
98 }
99 
100 
101 char *
102 ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
103 {
104  char *rv;
105  ngx_fd_t fd;
106  ngx_int_t rc;
107  ngx_buf_t buf;
108  ngx_conf_file_t *prev, conf_file;
109  enum {
110  parse_file = 0,
111  parse_block,
112  parse_param
113  } type;
114 
115 #if (NGX_SUPPRESS_WARN)
116  fd = NGX_INVALID_FILE;
117  prev = NULL;
118 #endif
119 
120  if (filename) {
121 
122  /* open configuration file */
123 
124  fd = ngx_open_file(filename->data, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);
125  if (fd == NGX_INVALID_FILE) {
126  ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
127  ngx_open_file_n " \"%s\" failed",
128  filename->data);
129  return NGX_CONF_ERROR;
130  }
131 
132  prev = cf->conf_file;
133 
134  cf->conf_file = &conf_file;
135 
136  if (ngx_fd_info(fd, &cf->conf_file->file.info) == NGX_FILE_ERROR) {
137  ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
138  ngx_fd_info_n " \"%s\" failed", filename->data);
139  }
140 
141  cf->conf_file->buffer = &buf;
142 
143  buf.start = ngx_alloc(NGX_CONF_BUFFER, cf->log);
144  if (buf.start == NULL) {
145  goto failed;
146  }
147 
148  buf.pos = buf.start;
149  buf.last = buf.start;
150  buf.end = buf.last + NGX_CONF_BUFFER;
151  buf.temporary = 1;
152 
153  cf->conf_file->file.fd = fd;
154  cf->conf_file->file.name.len = filename->len;
155  cf->conf_file->file.name.data = filename->data;
156  cf->conf_file->file.offset = 0;
157  cf->conf_file->file.log = cf->log;
158  cf->conf_file->line = 1;
159 
160  type = parse_file;
161 
162  } else if (cf->conf_file->file.fd != NGX_INVALID_FILE) {
163 
164  type = parse_block;
165 
166  } else {
167  type = parse_param;
168  }
169 
170 
171  for ( ;; ) {
172  rc = ngx_conf_read_token(cf);
173 
174  /*
175  * ngx_conf_read_token() may return
176  *
177  * NGX_ERROR there is error
178  * NGX_OK the token terminated by ";" was found
179  * NGX_CONF_BLOCK_START the token terminated by "{" was found
180  * NGX_CONF_BLOCK_DONE the "}" was found
181  * NGX_CONF_FILE_DONE the configuration file is done
182  */
183 
184  if (rc == NGX_ERROR) {
185  goto done;
186  }
187 
188  if (rc == NGX_CONF_BLOCK_DONE) {
189 
190  if (type != parse_block) {
191  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unexpected \"}\"");
192  goto failed;
193  }
194 
195  goto done;
196  }
197 
198  if (rc == NGX_CONF_FILE_DONE) {
199 
200  if (type == parse_block) {
201  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
202  "unexpected end of file, expecting \"}\"");
203  goto failed;
204  }
205 
206  goto done;
207  }
208 
209  if (rc == NGX_CONF_BLOCK_START) {
210 
211  if (type == parse_param) {
212  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
213  "block directives are not supported "
214  "in -g option");
215  goto failed;
216  }
217  }
218 
219  /* rc == NGX_OK || rc == NGX_CONF_BLOCK_START */
220 
221  if (cf->handler) {
222 
223  /*
224  * the custom handler, i.e., that is used in the http's
225  * "types { ... }" directive
226  */
227 
228  rv = (*cf->handler)(cf, NULL, cf->handler_conf);
229  if (rv == NGX_CONF_OK) {
230  continue;
231  }
232 
233  if (rv == NGX_CONF_ERROR) {
234  goto failed;
235  }
236 
237  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, rv);
238 
239  goto failed;
240  }
241 
242 
243  rc = ngx_conf_handler(cf, rc);
244 
245  if (rc == NGX_ERROR) {
246  goto failed;
247  }
248  }
249 
250 failed:
251 
252  rc = NGX_ERROR;
253 
254 done:
255 
256  if (filename) {
257  if (cf->conf_file->buffer->start) {
258  ngx_free(cf->conf_file->buffer->start);
259  }
260 
261  if (ngx_close_file(fd) == NGX_FILE_ERROR) {
262  ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
263  ngx_close_file_n " %s failed",
264  filename->data);
265  return NGX_CONF_ERROR;
266  }
267 
268  cf->conf_file = prev;
269  }
270 
271  if (rc == NGX_ERROR) {
272  return NGX_CONF_ERROR;
273  }
274 
275  return NGX_CONF_OK;
276 }
277 
278 
279 static ngx_int_t
280 ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last)
281 {
282  char *rv;
283  void *conf, **confp;
284  ngx_uint_t i, found;
285  ngx_str_t *name;
286  ngx_command_t *cmd;
287 
288  name = cf->args->elts;
289 
290  found = 0;
291 
292  for (i = 0; ngx_modules[i]; i++) {
293 
294  cmd = ngx_modules[i]->commands;
295  if (cmd == NULL) {
296  continue;
297  }
298 
299  for ( /* void */ ; cmd->name.len; cmd++) {
300 
301  if (name->len != cmd->name.len) {
302  continue;
303  }
304 
305  if (ngx_strcmp(name->data, cmd->name.data) != 0) {
306  continue;
307  }
308 
309  found = 1;
310 
311  if (ngx_modules[i]->type != NGX_CONF_MODULE
312  && ngx_modules[i]->type != cf->module_type)
313  {
314  continue;
315  }
316 
317  /* is the directive's location right ? */
318 
319  if (!(cmd->type & cf->cmd_type)) {
320  continue;
321  }
322 
323  if (!(cmd->type & NGX_CONF_BLOCK) && last != NGX_OK) {
324  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
325  "directive \"%s\" is not terminated by \";\"",
326  name->data);
327  return NGX_ERROR;
328  }
329 
330  if ((cmd->type & NGX_CONF_BLOCK) && last != NGX_CONF_BLOCK_START) {
331  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
332  "directive \"%s\" has no opening \"{\"",
333  name->data);
334  return NGX_ERROR;
335  }
336 
337  /* is the directive's argument count right ? */
338 
339  if (!(cmd->type & NGX_CONF_ANY)) {
340 
341  if (cmd->type & NGX_CONF_FLAG) {
342 
343  if (cf->args->nelts != 2) {
344  goto invalid;
345  }
346 
347  } else if (cmd->type & NGX_CONF_1MORE) {
348 
349  if (cf->args->nelts < 2) {
350  goto invalid;
351  }
352 
353  } else if (cmd->type & NGX_CONF_2MORE) {
354 
355  if (cf->args->nelts < 3) {
356  goto invalid;
357  }
358 
359  } else if (cf->args->nelts > NGX_CONF_MAX_ARGS) {
360 
361  goto invalid;
362 
363  } else if (!(cmd->type & argument_number[cf->args->nelts - 1]))
364  {
365  goto invalid;
366  }
367  }
368 
369  /* set up the directive's configuration context */
370 
371  conf = NULL;
372 
373  if (cmd->type & NGX_DIRECT_CONF) {
374  conf = ((void **) cf->ctx)[ngx_modules[i]->index];
375 
376  } else if (cmd->type & NGX_MAIN_CONF) {
377  conf = &(((void **) cf->ctx)[ngx_modules[i]->index]);
378 
379  } else if (cf->ctx) {
380  confp = *(void **) ((char *) cf->ctx + cmd->conf);
381 
382  if (confp) {
383  conf = confp[ngx_modules[i]->ctx_index];
384  }
385  }
386 
387  rv = cmd->set(cf, cmd, conf);
388 
389  if (rv == NGX_CONF_OK) {
390  return NGX_OK;
391  }
392 
393  if (rv == NGX_CONF_ERROR) {
394  return NGX_ERROR;
395  }
396 
397  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
398  "\"%s\" directive %s", name->data, rv);
399 
400  return NGX_ERROR;
401  }
402  }
403 
404  if (found) {
405  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
406  "\"%s\" directive is not allowed here", name->data);
407 
408  return NGX_ERROR;
409  }
410 
411  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
412  "unknown directive \"%s\"", name->data);
413 
414  return NGX_ERROR;
415 
416 invalid:
417 
418  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
419  "invalid number of arguments in \"%s\" directive",
420  name->data);
421 
422  return NGX_ERROR;
423 }
424 
425 
426 static ngx_int_t
427 ngx_conf_read_token(ngx_conf_t *cf)
428 {
429  u_char *start, ch, *src, *dst;
430  off_t file_size;
431  size_t len;
432  ssize_t n, size;
433  ngx_uint_t found, need_space, last_space, sharp_comment, variable;
434  ngx_uint_t quoted, s_quoted, d_quoted, start_line;
435  ngx_str_t *word;
436  ngx_buf_t *b;
437 
438  found = 0;
439  need_space = 0;
440  last_space = 1;
441  sharp_comment = 0;
442  variable = 0;
443  quoted = 0;
444  s_quoted = 0;
445  d_quoted = 0;
446 
447  cf->args->nelts = 0;
448  b = cf->conf_file->buffer;
449  start = b->pos;
450  start_line = cf->conf_file->line;
451 
452  file_size = ngx_file_size(&cf->conf_file->file.info);
453 
454  for ( ;; ) {
455 
456  if (b->pos >= b->last) {
457 
458  if (cf->conf_file->file.offset >= file_size) {
459 
460  if (cf->args->nelts > 0 || !last_space) {
461 
462  if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
463  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
464  "unexpected end of parameter, "
465  "expecting \";\"");
466  return NGX_ERROR;
467  }
468 
469  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
470  "unexpected end of file, "
471  "expecting \";\" or \"}\"");
472  return NGX_ERROR;
473  }
474 
475  return NGX_CONF_FILE_DONE;
476  }
477 
478  len = b->pos - start;
479 
480  if (len == NGX_CONF_BUFFER) {
481  cf->conf_file->line = start_line;
482 
483  if (d_quoted) {
484  ch = '"';
485 
486  } else if (s_quoted) {
487  ch = '\'';
488 
489  } else {
490  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
491  "too long parameter \"%*s...\" started",
492  10, start);
493  return NGX_ERROR;
494  }
495 
496  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
497  "too long parameter, probably "
498  "missing terminating \"%c\" character", ch);
499  return NGX_ERROR;
500  }
501 
502  if (len) {
503  ngx_memmove(b->start, start, len);
504  }
505 
506  size = (ssize_t) (file_size - cf->conf_file->file.offset);
507 
508  if (size > b->end - (b->start + len)) {
509  size = b->end - (b->start + len);
510  }
511 
512  n = ngx_read_file(&cf->conf_file->file, b->start + len, size,
513  cf->conf_file->file.offset);
514 
515  if (n == NGX_ERROR) {
516  return NGX_ERROR;
517  }
518 
519  if (n != size) {
520  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
521  ngx_read_file_n " returned "
522  "only %z bytes instead of %z",
523  n, size);
524  return NGX_ERROR;
525  }
526 
527  b->pos = b->start + len;
528  b->last = b->pos + n;
529  start = b->start;
530  }
531 
532  ch = *b->pos++;
533 
534  if (ch == LF) {
535  cf->conf_file->line++;
536 
537  if (sharp_comment) {
538  sharp_comment = 0;
539  }
540  }
541 
542  if (sharp_comment) {
543  continue;
544  }
545 
546  if (quoted) {
547  quoted = 0;
548  continue;
549  }
550 
551  if (need_space) {
552  if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
553  last_space = 1;
554  need_space = 0;
555  continue;
556  }
557 
558  if (ch == ';') {
559  return NGX_OK;
560  }
561 
562  if (ch == '{') {
563  return NGX_CONF_BLOCK_START;
564  }
565 
566  if (ch == ')') {
567  last_space = 1;
568  need_space = 0;
569 
570  } else {
571  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
572  "unexpected \"%c\"", ch);
573  return NGX_ERROR;
574  }
575  }
576 
577  if (last_space) {
578  if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
579  continue;
580  }
581 
582  start = b->pos - 1;
583  start_line = cf->conf_file->line;
584 
585  switch (ch) {
586 
587  case ';':
588  case '{':
589  if (cf->args->nelts == 0) {
590  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
591  "unexpected \"%c\"", ch);
592  return NGX_ERROR;
593  }
594 
595  if (ch == '{') {
596  return NGX_CONF_BLOCK_START;
597  }
598 
599  return NGX_OK;
600 
601  case '}':
602  if (cf->args->nelts != 0) {
603  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
604  "unexpected \"}\"");
605  return NGX_ERROR;
606  }
607 
608  return NGX_CONF_BLOCK_DONE;
609 
610  case '#':
611  sharp_comment = 1;
612  continue;
613 
614  case '\\':
615  quoted = 1;
616  last_space = 0;
617  continue;
618 
619  case '"':
620  start++;
621  d_quoted = 1;
622  last_space = 0;
623  continue;
624 
625  case '\'':
626  start++;
627  s_quoted = 1;
628  last_space = 0;
629  continue;
630 
631  default:
632  last_space = 0;
633  }
634 
635  } else {
636  if (ch == '{' && variable) {
637  continue;
638  }
639 
640  variable = 0;
641 
642  if (ch == '\\') {
643  quoted = 1;
644  continue;
645  }
646 
647  if (ch == '$') {
648  variable = 1;
649  continue;
650  }
651 
652  if (d_quoted) {
653  if (ch == '"') {
654  d_quoted = 0;
655  need_space = 1;
656  found = 1;
657  }
658 
659  } else if (s_quoted) {
660  if (ch == '\'') {
661  s_quoted = 0;
662  need_space = 1;
663  found = 1;
664  }
665 
666  } else if (ch == ' ' || ch == '\t' || ch == CR || ch == LF
667  || ch == ';' || ch == '{')
668  {
669  last_space = 1;
670  found = 1;
671  }
672 
673  if (found) {
674  word = ngx_array_push(cf->args);
675  if (word == NULL) {
676  return NGX_ERROR;
677  }
678 
679  word->data = ngx_pnalloc(cf->pool, b->pos - start + 1);
680  if (word->data == NULL) {
681  return NGX_ERROR;
682  }
683 
684  for (dst = word->data, src = start, len = 0;
685  src < b->pos - 1;
686  len++)
687  {
688  if (*src == '\\') {
689  switch (src[1]) {
690  case '"':
691  case '\'':
692  case '\\':
693  src++;
694  break;
695 
696  case 't':
697  *dst++ = '\t';
698  src += 2;
699  continue;
700 
701  case 'r':
702  *dst++ = '\r';
703  src += 2;
704  continue;
705 
706  case 'n':
707  *dst++ = '\n';
708  src += 2;
709  continue;
710  }
711 
712  }
713  *dst++ = *src++;
714  }
715  *dst = '\0';
716  word->len = len;
717 
718  if (ch == ';') {
719  return NGX_OK;
720  }
721 
722  if (ch == '{') {
723  return NGX_CONF_BLOCK_START;
724  }
725 
726  found = 0;
727  }
728  }
729  }
730 }
731 
732 
733 char *
734 ngx_conf_include(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
735 {
736  char *rv;
737  ngx_int_t n;
738  ngx_str_t *value, file, name;
739  ngx_glob_t gl;
740 
741  value = cf->args->elts;
742  file = value[1];
743 
744  ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
745 
746  if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
747  return NGX_CONF_ERROR;
748  }
749 
750  if (strpbrk((char *) file.data, "*?[") == NULL) {
751 
752  ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
753 
754  return ngx_conf_parse(cf, &file);
755  }
756 
757  ngx_memzero(&gl, sizeof(ngx_glob_t));
758 
759  gl.pattern = file.data;
760  gl.log = cf->log;
761  gl.test = 1;
762 
763  if (ngx_open_glob(&gl) != NGX_OK) {
764  ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
765  ngx_open_glob_n " \"%s\" failed", file.data);
766  return NGX_CONF_ERROR;
767  }
768 
769  rv = NGX_CONF_OK;
770 
771  for ( ;; ) {
772  n = ngx_read_glob(&gl, &name);
773 
774  if (n != NGX_OK) {
775  break;
776  }
777 
778  file.len = name.len++;
779  file.data = ngx_pstrdup(cf->pool, &name);
780 
781  ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);
782 
783  rv = ngx_conf_parse(cf, &file);
784 
785  if (rv != NGX_CONF_OK) {
786  break;
787  }
788  }
789 
790  ngx_close_glob(&gl);
791 
792  return rv;
793 }
794 
795 
796 ngx_int_t
797 ngx_conf_full_name(ngx_cycle_t *cycle, ngx_str_t *name, ngx_uint_t conf_prefix)
798 {
799  size_t len;
800  u_char *p, *n, *prefix;
801  ngx_int_t rc;
802 
803  rc = ngx_conf_test_full_name(name);
804 
805  if (rc == NGX_OK) {
806  return rc;
807  }
808 
809  if (conf_prefix) {
810  len = cycle->conf_prefix.len;
811  prefix = cycle->conf_prefix.data;
812 
813  } else {
814  len = cycle->prefix.len;
815  prefix = cycle->prefix.data;
816  }
817 
818 #if (NGX_WIN32)
819 
820  if (rc == 2) {
821  len = rc;
822  }
823 
824 #endif
825 
826  n = ngx_pnalloc(cycle->pool, len + name->len + 1);
827  if (n == NULL) {
828  return NGX_ERROR;
829  }
830 
831  p = ngx_cpymem(n, prefix, len);
832  ngx_cpystrn(p, name->data, name->len + 1);
833 
834  name->len += len;
835  name->data = n;
836 
837  return NGX_OK;
838 }
839 
840 
841 static ngx_int_t
842 ngx_conf_test_full_name(ngx_str_t *name)
843 {
844 #if (NGX_WIN32)
845  u_char c0, c1;
846 
847  c0 = name->data[0];
848 
849  if (name->len < 2) {
850  if (c0 == '/') {
851  return 2;
852  }
853 
854  return NGX_DECLINED;
855  }
856 
857  c1 = name->data[1];
858 
859  if (c1 == ':') {
860  c0 |= 0x20;
861 
862  if ((c0 >= 'a' && c0 <= 'z')) {
863  return NGX_OK;
864  }
865 
866  return NGX_DECLINED;
867  }
868 
869  if (c1 == '/') {
870  return NGX_OK;
871  }
872 
873  if (c0 == '/') {
874  return 2;
875  }
876 
877  return NGX_DECLINED;
878 
879 #else
880 
881  if (name->data[0] == '/') {
882  return NGX_OK;
883  }
884 
885  return NGX_DECLINED;
886 
887 #endif
888 }
889 
890 
891 ngx_open_file_t *
892 ngx_conf_open_file(ngx_cycle_t *cycle, ngx_str_t *name)
893 {
894  ngx_str_t full;
895  ngx_uint_t i;
896  ngx_list_part_t *part;
897  ngx_open_file_t *file;
898 
899 #if (NGX_SUPPRESS_WARN)
900  ngx_str_null(&full);
901 #endif
902 
903  if (name->len) {
904  full = *name;
905 
906  if (ngx_conf_full_name(cycle, &full, 0) != NGX_OK) {
907  return NULL;
908  }
909 
910  part = &cycle->open_files.part;
911  file = part->elts;
912 
913  for (i = 0; /* void */ ; i++) {
914 
915  if (i >= part->nelts) {
916  if (part->next == NULL) {
917  break;
918  }
919  part = part->next;
920  file = part->elts;
921  i = 0;
922  }
923 
924  if (full.len != file[i].name.len) {
925  continue;
926  }
927 
928  if (ngx_strcmp(full.data, file[i].name.data) == 0) {
929  return &file[i];
930  }
931  }
932  }
933 
934  file = ngx_list_push(&cycle->open_files);
935  if (file == NULL) {
936  return NULL;
937  }
938 
939  if (name->len) {
940  file->fd = NGX_INVALID_FILE;
941  file->name = full;
942 
943  } else {
944  file->fd = ngx_stderr;
945  file->name = *name;
946  }
947 
948  file->flush = NULL;
949  file->data = NULL;
950 
951  return file;
952 }
953 
954 
955 static void
956 ngx_conf_flush_files(ngx_cycle_t *cycle)
957 {
958  ngx_uint_t i;
959  ngx_list_part_t *part;
960  ngx_open_file_t *file;
961 
962  ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0, "flush files");
963 
964  part = &cycle->open_files.part;
965  file = part->elts;
966 
967  for (i = 0; /* void */ ; i++) {
968 
969  if (i >= part->nelts) {
970  if (part->next == NULL) {
971  break;
972  }
973  part = part->next;
974  file = part->elts;
975  i = 0;
976  }
977 
978  if (file[i].flush) {
979  file[i].flush(&file[i], cycle->log);
980  }
981  }
982 }
983 
984 
985 void ngx_cdecl
986 ngx_conf_log_error(ngx_uint_t level, ngx_conf_t *cf, ngx_err_t err,
987  const char *fmt, ...)
988 {
989  u_char errstr[NGX_MAX_CONF_ERRSTR], *p, *last;
990  va_list args;
991 
992  last = errstr + NGX_MAX_CONF_ERRSTR;
993 
994  va_start(args, fmt);
995  p = ngx_vslprintf(errstr, last, fmt, args);
996  va_end(args);
997 
998  if (err) {
999  p = ngx_log_errno(p, last, err);
1000  }
1001 
1002  if (cf->conf_file == NULL) {
1003  ngx_log_error(level, cf->log, 0, "%*s", p - errstr, errstr);
1004  return;
1005  }
1006 
1007  if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
1008  ngx_log_error(level, cf->log, 0, "%*s in command line",
1009  p - errstr, errstr);
1010  return;
1011  }
1012 
1013  ngx_log_error(level, cf->log, 0, "%*s in %s:%ui",
1014  p - errstr, errstr,
1015  cf->conf_file->file.name.data, cf->conf_file->line);
1016 }
1017 
1018 
1019 char *
1020 ngx_conf_set_flag_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1021 {
1022  char *p = conf;
1023 
1024  ngx_str_t *value;
1025  ngx_flag_t *fp;
1026  ngx_conf_post_t *post;
1027 
1028  fp = (ngx_flag_t *) (p + cmd->offset);
1029 
1030  if (*fp != NGX_CONF_UNSET) {
1031  return "is duplicate";
1032  }
1033 
1034  value = cf->args->elts;
1035 
1036  if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
1037  *fp = 1;
1038 
1039  } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
1040  *fp = 0;
1041 
1042  } else {
1043  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1044  "invalid value \"%s\" in \"%s\" directive, "
1045  "it must be \"on\" or \"off\"",
1046  value[1].data, cmd->name.data);
1047  return NGX_CONF_ERROR;
1048  }
1049 
1050  if (cmd->post) {
1051  post = cmd->post;
1052  return post->post_handler(cf, post, fp);
1053  }
1054 
1055  return NGX_CONF_OK;
1056 }
1057 
1058 
1059 char *
1060 ngx_conf_set_str_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1061 {
1062  char *p = conf;
1063 
1064  ngx_str_t *field, *value;
1065  ngx_conf_post_t *post;
1066 
1067  field = (ngx_str_t *) (p + cmd->offset);
1068 
1069  if (field->data) {
1070  return "is duplicate";
1071  }
1072 
1073  value = cf->args->elts;
1074 
1075  *field = value[1];
1076 
1077  if (cmd->post) {
1078  post = cmd->post;
1079  return post->post_handler(cf, post, field);
1080  }
1081 
1082  return NGX_CONF_OK;
1083 }
1084 
1085 
1086 char *
1087 ngx_conf_set_str_array_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1088 {
1089  char *p = conf;
1090 
1091  ngx_str_t *value, *s;
1092  ngx_array_t **a;
1093  ngx_conf_post_t *post;
1094 
1095  a = (ngx_array_t **) (p + cmd->offset);
1096 
1097  if (*a == NGX_CONF_UNSET_PTR) {
1098  *a = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
1099  if (*a == NULL) {
1100  return NGX_CONF_ERROR;
1101  }
1102  }
1103 
1104  s = ngx_array_push(*a);
1105  if (s == NULL) {
1106  return NGX_CONF_ERROR;
1107  }
1108 
1109  value = cf->args->elts;
1110 
1111  *s = value[1];
1112 
1113  if (cmd->post) {
1114  post = cmd->post;
1115  return post->post_handler(cf, post, s);
1116  }
1117 
1118  return NGX_CONF_OK;
1119 }
1120 
1121 
1122 char *
1123 ngx_conf_set_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1124 {
1125  char *p = conf;
1126 
1127  ngx_str_t *value;
1128  ngx_array_t **a;
1129  ngx_keyval_t *kv;
1130  ngx_conf_post_t *post;
1131 
1132  a = (ngx_array_t **) (p + cmd->offset);
1133 
1134  if (*a == NULL) {
1135  *a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
1136  if (*a == NULL) {
1137  return NGX_CONF_ERROR;
1138  }
1139  }
1140 
1141  kv = ngx_array_push(*a);
1142  if (kv == NULL) {
1143  return NGX_CONF_ERROR;
1144  }
1145 
1146  value = cf->args->elts;
1147 
1148  kv->key = value[1];
1149  kv->value = value[2];
1150 
1151  if (cmd->post) {
1152  post = cmd->post;
1153  return post->post_handler(cf, post, kv);
1154  }
1155 
1156  return NGX_CONF_OK;
1157 }
1158 
1159 
1160 char *
1161 ngx_conf_set_num_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1162 {
1163  char *p = conf;
1164 
1165  ngx_int_t *np;
1166  ngx_str_t *value;
1167  ngx_conf_post_t *post;
1168 
1169 
1170  np = (ngx_int_t *) (p + cmd->offset);
1171 
1172  if (*np != NGX_CONF_UNSET) {
1173  return "is duplicate";
1174  }
1175 
1176  value = cf->args->elts;
1177  *np = ngx_atoi(value[1].data, value[1].len);
1178  if (*np == NGX_ERROR) {
1179  return "invalid number";
1180  }
1181 
1182  if (cmd->post) {
1183  post = cmd->post;
1184  return post->post_handler(cf, post, np);
1185  }
1186 
1187  return NGX_CONF_OK;
1188 }
1189 
1190 
1191 char *
1192 ngx_conf_set_size_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1193 {
1194  char *p = conf;
1195 
1196  size_t *sp;
1197  ngx_str_t *value;
1198  ngx_conf_post_t *post;
1199 
1200 
1201  sp = (size_t *) (p + cmd->offset);
1202  if (*sp != NGX_CONF_UNSET_SIZE) {
1203  return "is duplicate";
1204  }
1205 
1206  value = cf->args->elts;
1207 
1208  *sp = ngx_parse_size(&value[1]);
1209  if (*sp == (size_t) NGX_ERROR) {
1210  return "invalid value";
1211  }
1212 
1213  if (cmd->post) {
1214  post = cmd->post;
1215  return post->post_handler(cf, post, sp);
1216  }
1217 
1218  return NGX_CONF_OK;
1219 }
1220 
1221 
1222 char *
1223 ngx_conf_set_off_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1224 {
1225  char *p = conf;
1226 
1227  off_t *op;
1228  ngx_str_t *value;
1229  ngx_conf_post_t *post;
1230 
1231 
1232  op = (off_t *) (p + cmd->offset);
1233  if (*op != NGX_CONF_UNSET) {
1234  return "is duplicate";
1235  }
1236 
1237  value = cf->args->elts;
1238 
1239  *op = ngx_parse_offset(&value[1]);
1240  if (*op == (off_t) NGX_ERROR) {
1241  return "invalid value";
1242  }
1243 
1244  if (cmd->post) {
1245  post = cmd->post;
1246  return post->post_handler(cf, post, op);
1247  }
1248 
1249  return NGX_CONF_OK;
1250 }
1251 
1252 
1253 char *
1254 ngx_conf_set_msec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1255 {
1256  char *p = conf;
1257 
1258  ngx_msec_t *msp;
1259  ngx_str_t *value;
1260  ngx_conf_post_t *post;
1261 
1262 
1263  msp = (ngx_msec_t *) (p + cmd->offset);
1264  if (*msp != NGX_CONF_UNSET_MSEC) {
1265  return "is duplicate";
1266  }
1267 
1268  value = cf->args->elts;
1269 
1270  *msp = ngx_parse_time(&value[1], 0);
1271  if (*msp == (ngx_msec_t) NGX_ERROR) {
1272  return "invalid value";
1273  }
1274 
1275  if (cmd->post) {
1276  post = cmd->post;
1277  return post->post_handler(cf, post, msp);
1278  }
1279 
1280  return NGX_CONF_OK;
1281 }
1282 
1283 
1284 char *
1285 ngx_conf_set_sec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1286 {
1287  char *p = conf;
1288 
1289  time_t *sp;
1290  ngx_str_t *value;
1291  ngx_conf_post_t *post;
1292 
1293 
1294  sp = (time_t *) (p + cmd->offset);
1295  if (*sp != NGX_CONF_UNSET) {
1296  return "is duplicate";
1297  }
1298 
1299  value = cf->args->elts;
1300 
1301  *sp = ngx_parse_time(&value[1], 1);
1302  if (*sp == (time_t) NGX_ERROR) {
1303  return "invalid value";
1304  }
1305 
1306  if (cmd->post) {
1307  post = cmd->post;
1308  return post->post_handler(cf, post, sp);
1309  }
1310 
1311  return NGX_CONF_OK;
1312 }
1313 
1314 
1315 char *
1316 ngx_conf_set_bufs_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1317 {
1318  char *p = conf;
1319 
1320  ngx_str_t *value;
1321  ngx_bufs_t *bufs;
1322 
1323 
1324  bufs = (ngx_bufs_t *) (p + cmd->offset);
1325  if (bufs->num) {
1326  return "is duplicate";
1327  }
1328 
1329  value = cf->args->elts;
1330 
1331  bufs->num = ngx_atoi(value[1].data, value[1].len);
1332  if (bufs->num == NGX_ERROR || bufs->num == 0) {
1333  return "invalid value";
1334  }
1335 
1336  bufs->size = ngx_parse_size(&value[2]);
1337  if (bufs->size == (size_t) NGX_ERROR || bufs->size == 0) {
1338  return "invalid value";
1339  }
1340 
1341  return NGX_CONF_OK;
1342 }
1343 
1344 
1345 char *
1346 ngx_conf_set_enum_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1347 {
1348  char *p = conf;
1349 
1350  ngx_uint_t *np, i;
1351  ngx_str_t *value;
1352  ngx_conf_enum_t *e;
1353 
1354  np = (ngx_uint_t *) (p + cmd->offset);
1355 
1356  if (*np != NGX_CONF_UNSET_UINT) {
1357  return "is duplicate";
1358  }
1359 
1360  value = cf->args->elts;
1361  e = cmd->post;
1362 
1363  for (i = 0; e[i].name.len != 0; i++) {
1364  if (e[i].name.len != value[1].len
1365  || ngx_strcasecmp(e[i].name.data, value[1].data) != 0)
1366  {
1367  continue;
1368  }
1369 
1370  *np = e[i].value;
1371 
1372  return NGX_CONF_OK;
1373  }
1374 
1375  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1376  "invalid value \"%s\"", value[1].data);
1377 
1378  return NGX_CONF_ERROR;
1379 }
1380 
1381 
1382 char *
1383 ngx_conf_set_bitmask_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1384 {
1385  char *p = conf;
1386 
1387  ngx_uint_t *np, i, m;
1388  ngx_str_t *value;
1389  ngx_conf_bitmask_t *mask;
1390 
1391 
1392  np = (ngx_uint_t *) (p + cmd->offset);
1393  value = cf->args->elts;
1394  mask = cmd->post;
1395 
1396  for (i = 1; i < cf->args->nelts; i++) {
1397  for (m = 0; mask[m].name.len != 0; m++) {
1398 
1399  if (mask[m].name.len != value[i].len
1400  || ngx_strcasecmp(mask[m].name.data, value[i].data) != 0)
1401  {
1402  continue;
1403  }
1404 
1405  if (*np & mask[m].mask) {
1406  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1407  "duplicate value \"%s\"", value[i].data);
1408 
1409  } else {
1410  *np |= mask[m].mask;
1411  }
1412 
1413  break;
1414  }
1415 
1416  if (mask[m].name.len == 0) {
1417  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1418  "invalid value \"%s\"", value[i].data);
1419 
1420  return NGX_CONF_ERROR;
1421  }
1422  }
1423 
1424  return NGX_CONF_OK;
1425 }
1426 
1427 
1428 #if 0
1429 
1430 char *
1431 ngx_conf_unsupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
1432 {
1433  return "unsupported on this platform";
1434 }
1435 
1436 #endif
1437 
1438 
1439 char *
1440 ngx_conf_deprecated(ngx_conf_t *cf, void *post, void *data)
1441 {
1442  ngx_conf_deprecated_t *d = post;
1443 
1444  ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
1445  "the \"%s\" directive is deprecated, "
1446  "use the \"%s\" directive instead",
1447  d->old_name, d->new_name);
1448 
1449  return NGX_CONF_OK;
1450 }
1451 
1452 
1453 char *
1454 ngx_conf_check_num_bounds(ngx_conf_t *cf, void *post, void *data)
1455 {
1456  ngx_conf_num_bounds_t *bounds = post;
1457  ngx_int_t *np = data;
1458 
1459  if (bounds->high == -1) {
1460  if (*np >= bounds->low) {
1461  return NGX_CONF_OK;
1462  }
1463 
1464  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1465  "value must be equal to or greater than %i",
1466  bounds->low);
1467 
1468  return NGX_CONF_ERROR;
1469  }
1470 
1471  if (*np >= bounds->low && *np <= bounds->high) {
1472  return NGX_CONF_OK;
1473  }
1474 
1475  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
1476  "value must be between %i and %i",
1477  bounds->low, bounds->high);
1478 
1479  return NGX_CONF_ERROR;
1480 }
Generated on Sun Nov 10 2013 09:49:06 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2