One Level Up Top Level

src/core/ngx_conf_file.c - nginx-1.7.10

Global variables defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>

  11. ‌#define NGX_CONF_BUFFER  4096

  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 void ngx_conf_flush_files(ngx_cycle_t *cycle);


  18. ‌static ngx_command_t  ngx_conf_commands[] = {

  20.     { ngx_string("include"),
  21.       NGX_ANY_CONF|NGX_CONF_TAKE1,
  22.       ngx_conf_include,
  23.       0,
  24.       0,
  25.       NULL },

  27.       ngx_null_command
  28. };


  31. ‌ngx_module_t  ngx_conf_module = {
  32.     NGX_MODULE_V1,
  33.     NULL,                                  /* module context */
  34.     ngx_conf_commands,                     /* module directives */
  35.     NGX_CONF_MODULE,                       /* module type */
  36.     NULL,                                  /* init master */
  37.     NULL,                                  /* init module */
  38.     NULL,                                  /* init process */
  39.     NULL,                                  /* init thread */
  40.     NULL,                                  /* exit thread */
  41.     ngx_conf_flush_files,                  /* exit process */
  42.     NULL,                                  /* exit master */
  43.     NGX_MODULE_V1_PADDING
  44. };


  47. /* The eight fixed arguments */

  49. ‌static ngx_uint_t argument_number[] = {
  50.     NGX_CONF_NOARGS,
  51.     NGX_CONF_TAKE1,
  52.     NGX_CONF_TAKE2,
  53.     NGX_CONF_TAKE3,
  54.     NGX_CONF_TAKE4,
  55.     NGX_CONF_TAKE5,
  56.     NGX_CONF_TAKE6,
  57.     NGX_CONF_TAKE7
  58. };


  61. char *
  62. ‌ngx_conf_param(ngx_conf_t *cf)
  63. {
  64.     char             *rv;
  65.     ngx_str_t        *param;
  66.     ngx_buf_t         b;
  67.     ngx_conf_file_t   conf_file;

  69.     param = &cf->cycle->conf_param;

  71.     if (param->len == 0) {
  72.         return NGX_CONF_OK;
  73.     }

  75.     ngx_memzero(&conf_file, sizeof(ngx_conf_file_t));

  77.     ngx_memzero(&b, sizeof(ngx_buf_t));

  79.     b.start = param->data;
  80.     b.pos = param->data;
  81.     b.last = param->data + param->len;
  82.     b.end = b.last;
  83.     b.temporary = 1;

  85.     conf_file.file.fd = NGX_INVALID_FILE;
  86.     conf_file.file.name.data = NULL;
  87.     conf_file.line = 0;

  89.     cf->conf_file = &conf_file;
  90.     cf->conf_file->buffer = &b;

  92.     rv = ngx_conf_parse(cf, NULL);

  94.     cf->conf_file = NULL;

  96.     return rv;
  97. }


  100. char *
  101. ‌ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
  102. {
  103.     char             *rv;
  104.     ngx_fd_t          fd;
  105.     ngx_int_t         rc;
  106.     ngx_buf_t         buf;
  107.     ngx_conf_file_t  *prev, conf_file;
  108.     enum {
  109.         parse_file = 0,
  110.         parse_block,
  111.         parse_param
  112.     } type;

  114. #if (NGX_SUPPRESS_WARN)
  115.     fd = NGX_INVALID_FILE;
  116.     prev = NULL;
  117. #endif

  119.     if (filename) {

  121.         /* open configuration file */

  123.         fd = ngx_open_file(filename->data, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);
  124.         if (fd == NGX_INVALID_FILE) {
  125.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  126.                                ngx_open_file_n " \"%s\" failed",
  127.                                filename->data);
  128.             return NGX_CONF_ERROR;
  129.         }

  131.         prev = cf->conf_file;

  133.         cf->conf_file = &conf_file;

  135.         if (ngx_fd_info(fd, &cf->conf_file->file.info) == NGX_FILE_ERROR) {
  136.             ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
  137.                           ngx_fd_info_n " \"%s\" failed", filename->data);
  138.         }

  140.         cf->conf_file->buffer = &buf;

  142.         buf.start = ngx_alloc(NGX_CONF_BUFFER, cf->log);
  143.         if (buf.start == NULL) {
  144.             goto failed;
  145.         }

  147.         buf.pos = buf.start;
  148.         buf.last = buf.start;
  149.         buf.end = buf.last + NGX_CONF_BUFFER;
  150.         buf.temporary = 1;

  152.         cf->conf_file->file.fd = fd;
  153.         cf->conf_file->file.name.len = filename->len;
  154.         cf->conf_file->file.name.data = filename->data;
  155.         cf->conf_file->file.offset = 0;
  156.         cf->conf_file->file.log = cf->log;
  157.         cf->conf_file->line = 1;

  159.         type = parse_file;

  161.     } else if (cf->conf_file->file.fd != NGX_INVALID_FILE) {

  163.         type = parse_block;

  165.     } else {
  166.         type = parse_param;
  167.     }


  170.     for ( ;; ) {
  171.         rc = ngx_conf_read_token(cf);

  173.         /*
  174.          * ngx_conf_read_token() may return
  175.          *
  176.          *    NGX_ERROR             there is error
  177.          *    NGX_OK                the token terminated by ";" was found
  178.          *    NGX_CONF_BLOCK_START  the token terminated by "{" was found
  179.          *    NGX_CONF_BLOCK_DONE   the "}" was found
  180.          *    NGX_CONF_FILE_DONE    the configuration file is done
  181.          */

  183.         if (rc == NGX_ERROR) {
  184.             goto done;
  185.         }

  187.         if (rc == NGX_CONF_BLOCK_DONE) {

  189.             if (type != parse_block) {
  190.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unexpected \"}\"");
  191.                 goto failed;
  192.             }

  194.             goto done;
  195.         }

  197.         if (rc == NGX_CONF_FILE_DONE) {

  199.             if (type == parse_block) {
  200.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  201.                                    "unexpected end of file, expecting \"}\"");
  202.                 goto failed;
  203.             }

  205.             goto done;
  206.         }

  208.         if (rc == NGX_CONF_BLOCK_START) {

  210.             if (type == parse_param) {
  211.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  212.                                    "block directives are not supported "
  213.                                    "in -g option");
  214.                 goto failed;
  215.             }
  216.         }

  218.         /* rc == NGX_OK || rc == NGX_CONF_BLOCK_START */

  220.         if (cf->handler) {

  222.             /*
  223.              * the custom handler, i.e., that is used in the http's
  224.              * "types { ... }" directive
  225.              */

  227.             if (rc == NGX_CONF_BLOCK_START) {
  228.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unexpected \"{\"");
  229.                 goto failed;
  230.             }

  232.             rv = (*cf->handler)(cf, NULL, cf->handler_conf);
  233.             if (rv == NGX_CONF_OK) {
  234.                 continue;
  235.             }

  237.             if (rv == NGX_CONF_ERROR) {
  238.                 goto failed;
  239.             }

  241.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, rv);

  243.             goto failed;
  244.         }


  247.         rc = ngx_conf_handler(cf, rc);

  249.         if (rc == NGX_ERROR) {
  250.             goto failed;
  251.         }
  252.     }

  254. failed:

  256.     rc = NGX_ERROR;

  258. done:

  260.     if (filename) {
  261.         if (cf->conf_file->buffer->start) {
  262.             ngx_free(cf->conf_file->buffer->start);
  263.         }

  265.         if (ngx_close_file(fd) == NGX_FILE_ERROR) {
  266.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  267.                           ngx_close_file_n " %s failed",
  268.                           filename->data);
  269.             rc = NGX_ERROR;
  270.         }

  272.         cf->conf_file = prev;
  273.     }

  275.     if (rc == NGX_ERROR) {
  276.         return NGX_CONF_ERROR;
  277.     }

  279.     return NGX_CONF_OK;
  280. }


  283. static ngx_int_t
  284. ‌ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last)
  285. {
  286.     char           *rv;
  287.     void           *conf, **confp;
  288.     ngx_uint_t      i, found;
  289.     ngx_str_t      *name;
  290.     ngx_command_t  *cmd;

  292.     name = cf->args->elts;

  294.     found = 0;

  296.     for (i = 0; ngx_modules[i]; i++) {

  298.         cmd = ngx_modules[i]->commands;
  299.         if (cmd == NULL) {
  300.             continue;
  301.         }

  303.         for ( /* void */ ; cmd->name.len; cmd++) {

  305.             if (name->len != cmd->name.len) {
  306.                 continue;
  307.             }

  309.             if (ngx_strcmp(name->data, cmd->name.data) != 0) {
  310.                 continue;
  311.             }

  313.             found = 1;

  315.             if (ngx_modules[i]->type != NGX_CONF_MODULE
  316.                 && ngx_modules[i]->type != cf->module_type)
  317.             {
  318.                 continue;
  319.             }

  321.             /* is the directive's location right ? */

  323.             if (!(cmd->type & cf->cmd_type)) {
  324.                 continue;
  325.             }

  327.             if (!(cmd->type & NGX_CONF_BLOCK) && last != NGX_OK) {
  328.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  329.                                   "directive \"%s\" is not terminated by \";\"",
  330.                                   name->data);
  331.                 return NGX_ERROR;
  332.             }

  334.             if ((cmd->type & NGX_CONF_BLOCK) && last != NGX_CONF_BLOCK_START) {
  335.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  336.                                    "directive \"%s\" has no opening \"{\"",
  337.                                    name->data);
  338.                 return NGX_ERROR;
  339.             }

  341.             /* is the directive's argument count right ? */

  343.             if (!(cmd->type & NGX_CONF_ANY)) {

  345.                 if (cmd->type & NGX_CONF_FLAG) {

  347.                     if (cf->args->nelts != 2) {
  348.                         goto invalid;
  349.                     }

  351.                 } else if (cmd->type & NGX_CONF_1MORE) {

  353.                     if (cf->args->nelts < 2) {
  354.                         goto invalid;
  355.                     }

  357.                 } else if (cmd->type & NGX_CONF_2MORE) {

  359.                     if (cf->args->nelts < 3) {
  360.                         goto invalid;
  361.                     }

  363.                 } else if (cf->args->nelts > NGX_CONF_MAX_ARGS) {

  365.                     goto invalid;

  367.                 } else if (!(cmd->type & argument_number[cf->args->nelts - 1]))
  368.                 {
  369.                     goto invalid;
  370.                 }
  371.             }

  373.             /* set up the directive's configuration context */

  375.             conf = NULL;

  377.             if (cmd->type & NGX_DIRECT_CONF) {
  378.                 conf = ((void **) cf->ctx)[ngx_modules[i]->index];

  380.             } else if (cmd->type & NGX_MAIN_CONF) {
  381.                 conf = &(((void **) cf->ctx)[ngx_modules[i]->index]);

  383.             } else if (cf->ctx) {
  384.                 confp = *(void **) ((char *) cf->ctx + cmd->conf);

  386.                 if (confp) {
  387.                     conf = confp[ngx_modules[i]->ctx_index];
  388.                 }
  389.             }

  391.             rv = cmd->set(cf, cmd, conf);

  393.             if (rv == NGX_CONF_OK) {
  394.                 return NGX_OK;
  395.             }

  397.             if (rv == NGX_CONF_ERROR) {
  398.                 return NGX_ERROR;
  399.             }

  401.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  402.                                "\"%s\" directive %s", name->data, rv);

  404.             return NGX_ERROR;
  405.         }
  406.     }

  408.     if (found) {
  409.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  410.                            "\"%s\" directive is not allowed here", name->data);

  412.         return NGX_ERROR;
  413.     }

  415.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  416.                        "unknown directive \"%s\"", name->data);

  418.     return NGX_ERROR;

  420. invalid:

  422.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  423.                        "invalid number of arguments in \"%s\" directive",
  424.                        name->data);

  426.     return NGX_ERROR;
  427. }


  430. static ngx_int_t
  431. ‌ngx_conf_read_token(ngx_conf_t *cf)
  432. {
  433.     u_char      *start, ch, *src, *dst;
  434.     off_t        file_size;
  435.     size_t       len;
  436.     ssize_t      n, size;
  437.     ngx_uint_t   found, need_space, last_space, sharp_comment, variable;
  438.     ngx_uint_t   quoted, s_quoted, d_quoted, start_line;
  439.     ngx_str_t   *word;
  440.     ngx_buf_t   *b;

  442.     found = 0;
  443.     need_space = 0;
  444.     last_space = 1;
  445.     sharp_comment = 0;
  446.     variable = 0;
  447.     quoted = 0;
  448.     s_quoted = 0;
  449.     d_quoted = 0;

  451.     cf->args->nelts = 0;
  452.     b = cf->conf_file->buffer;
  453.     start = b->pos;
  454.     start_line = cf->conf_file->line;

  456.     file_size = ngx_file_size(&cf->conf_file->file.info);

  458.     for ( ;; ) {

  460.         if (b->pos >= b->last) {

  462.             if (cf->conf_file->file.offset >= file_size) {

  464.                 if (cf->args->nelts > 0 || !last_space) {

  466.                     if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
  467.                         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  468.                                            "unexpected end of parameter, "
  469.                                            "expecting \";\"");
  470.                         return NGX_ERROR;
  471.                     }

  473.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  474.                                   "unexpected end of file, "
  475.                                   "expecting \";\" or \"}\"");
  476.                     return NGX_ERROR;
  477.                 }

  479.                 return NGX_CONF_FILE_DONE;
  480.             }

  482.             len = b->pos - start;

  484.             if (len == NGX_CONF_BUFFER) {
  485.                 cf->conf_file->line = start_line;

  487.                 if (d_quoted) {
  488.                     ch = '"';

  490.                 } else if (s_quoted) {
  491.                     ch = '\'';

  493.                 } else {
  494.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  495.                                        "too long parameter \"%*s...\" started",
  496.                                        10, start);
  497.                     return NGX_ERROR;
  498.                 }

  500.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  501.                                    "too long parameter, probably "
  502.                                    "missing terminating \"%c\" character", ch);
  503.                 return NGX_ERROR;
  504.             }

  506.             if (len) {
  507.                 ngx_memmove(b->start, start, len);
  508.             }

  510.             size = (ssize_t) (file_size - cf->conf_file->file.offset);

  512.             if (size > b->end - (b->start + len)) {
  513.                 size = b->end - (b->start + len);
  514.             }

  516.             n = ngx_read_file(&cf->conf_file->file, b->start + len, size,
  517.                               cf->conf_file->file.offset);

  519.             if (n == NGX_ERROR) {
  520.                 return NGX_ERROR;
  521.             }

  523.             if (n != size) {
  524.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  525.                                    ngx_read_file_n " returned "
  526.                                    "only %z bytes instead of %z",
  527.                                    n, size);
  528.                 return NGX_ERROR;
  529.             }

  531.             b->pos = b->start + len;
  532.             b->last = b->pos + n;
  533.             start = b->start;
  534.         }

  536.         ch = *b->pos++;

  538.         if (ch == LF) {
  539.             cf->conf_file->line++;

  541.             if (sharp_comment) {
  542.                 sharp_comment = 0;
  543.             }
  544.         }

  546.         if (sharp_comment) {
  547.             continue;
  548.         }

  550.         if (quoted) {
  551.             quoted = 0;
  552.             continue;
  553.         }

  555.         if (need_space) {
  556.             if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
  557.                 last_space = 1;
  558.                 need_space = 0;
  559.                 continue;
  560.             }

  562.             if (ch == ';') {
  563.                 return NGX_OK;
  564.             }

  566.             if (ch == '{') {
  567.                 return NGX_CONF_BLOCK_START;
  568.             }

  570.             if (ch == ')') {
  571.                 last_space = 1;
  572.                 need_space = 0;

  574.             } else {
  575.                  ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  576.                                     "unexpected \"%c\"", ch);
  577.                  return NGX_ERROR;
  578.             }
  579.         }

  581.         if (last_space) {
  582.             if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
  583.                 continue;
  584.             }

  586.             start = b->pos - 1;
  587.             start_line = cf->conf_file->line;

  589.             switch (ch) {

  591.             case ';':
  592.             case '{':
  593.                 if (cf->args->nelts == 0) {
  594.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  595.                                        "unexpected \"%c\"", ch);
  596.                     return NGX_ERROR;
  597.                 }

  599.                 if (ch == '{') {
  600.                     return NGX_CONF_BLOCK_START;
  601.                 }

  603.                 return NGX_OK;

  605.             case '}':
  606.                 if (cf->args->nelts != 0) {
  607.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  608.                                        "unexpected \"}\"");
  609.                     return NGX_ERROR;
  610.                 }

  612.                 return NGX_CONF_BLOCK_DONE;

  614.             case '#':
  615.                 sharp_comment = 1;
  616.                 continue;

  618.             case '\\':
  619.                 quoted = 1;
  620.                 last_space = 0;
  621.                 continue;

  623.             case '"':
  624.                 start++;
  625.                 d_quoted = 1;
  626.                 last_space = 0;
  627.                 continue;

  629.             case '\'':
  630.                 start++;
  631.                 s_quoted = 1;
  632.                 last_space = 0;
  633.                 continue;

  635.             default:
  636.                 last_space = 0;
  637.             }

  639.         } else {
  640.             if (ch == '{' && variable) {
  641.                 continue;
  642.             }

  644.             variable = 0;

  646.             if (ch == '\\') {
  647.                 quoted = 1;
  648.                 continue;
  649.             }

  651.             if (ch == '$') {
  652.                 variable = 1;
  653.                 continue;
  654.             }

  656.             if (d_quoted) {
  657.                 if (ch == '"') {
  658.                     d_quoted = 0;
  659.                     need_space = 1;
  660.                     found = 1;
  661.                 }

  663.             } else if (s_quoted) {
  664.                 if (ch == '\'') {
  665.                     s_quoted = 0;
  666.                     need_space = 1;
  667.                     found = 1;
  668.                 }

  670.             } else if (ch == ' ' || ch == '\t' || ch == CR || ch == LF
  671.                        || ch == ';' || ch == '{')
  672.             {
  673.                 last_space = 1;
  674.                 found = 1;
  675.             }

  677.             if (found) {
  678.                 word = ngx_array_push(cf->args);
  679.                 if (word == NULL) {
  680.                     return NGX_ERROR;
  681.                 }

  683.                 word->data = ngx_pnalloc(cf->pool, b->pos - start + 1);
  684.                 if (word->data == NULL) {
  685.                     return NGX_ERROR;
  686.                 }

  688.                 for (dst = word->data, src = start, len = 0;
  689.                      src < b->pos - 1;
  690.                      len++)
  691.                 {
  692.                     if (*src == '\\') {
  693.                         switch (src[1]) {
  694.                         case '"':
  695.                         case '\'':
  696.                         case '\\':
  697.                             src++;
  698.                             break;

  700.                         case 't':
  701.                             *dst++ = '\t';
  702.                             src += 2;
  703.                             continue;

  705.                         case 'r':
  706.                             *dst++ = '\r';
  707.                             src += 2;
  708.                             continue;

  710.                         case 'n':
  711.                             *dst++ = '\n';
  712.                             src += 2;
  713.                             continue;
  714.                         }

  716.                     }
  717.                     *dst++ = *src++;
  718.                 }
  719.                 *dst = '\0';
  720.                 word->len = len;

  722.                 if (ch == ';') {
  723.                     return NGX_OK;
  724.                 }

  726.                 if (ch == '{') {
  727.                     return NGX_CONF_BLOCK_START;
  728.                 }

  730.                 found = 0;
  731.             }
  732.         }
  733.     }
  734. }


  737. char *
  738. ‌ngx_conf_include(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  739. {
  740.     char        *rv;
  741.     ngx_int_t    n;
  742.     ngx_str_t   *value, file, name;
  743.     ngx_glob_t   gl;

  745.     value = cf->args->elts;
  746.     file = value[1];

  748.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);

  750.     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
  751.         return NGX_CONF_ERROR;
  752.     }

  754.     if (strpbrk((char *) file.data, "*?[") == NULL) {

  756.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);

  758.         return ngx_conf_parse(cf, &file);
  759.     }

  761.     ngx_memzero(&gl, sizeof(ngx_glob_t));

  763.     gl.pattern = file.data;
  764.     gl.log = cf->log;
  765.     gl.test = 1;

  767.     if (ngx_open_glob(&gl) != NGX_OK) {
  768.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  769.                            ngx_open_glob_n " \"%s\" failed", file.data);
  770.         return NGX_CONF_ERROR;
  771.     }

  773.     rv = NGX_CONF_OK;

  775.     for ( ;; ) {
  776.         n = ngx_read_glob(&gl, &name);

  778.         if (n != NGX_OK) {
  779.             break;
  780.         }

  782.         file.len = name.len++;
  783.         file.data = ngx_pstrdup(cf->pool, &name);
  784.         if (file.data == NULL) {
  785.             return NGX_CONF_ERROR;
  786.         }

  788.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, cf->log, 0, "include %s", file.data);

  790.         rv = ngx_conf_parse(cf, &file);

  792.         if (rv != NGX_CONF_OK) {
  793.             break;
  794.         }
  795.     }

  797.     ngx_close_glob(&gl);

  799.     return rv;
  800. }


  803. ngx_int_t
  804. ‌ngx_conf_full_name(ngx_cycle_t *cycle, ngx_str_t *name, ngx_uint_t conf_prefix)
  805. {
  806.     ngx_str_t  *prefix;

  808.     prefix = conf_prefix ? &cycle->conf_prefix : &cycle->prefix;

  810.     return ngx_get_full_name(cycle->pool, prefix, name);
  811. }


  814. ngx_open_file_t *
  815. ‌ngx_conf_open_file(ngx_cycle_t *cycle, ngx_str_t *name)
  816. {
  817.     ngx_str_t         full;
  818.     ngx_uint_t        i;
  819.     ngx_list_part_t  *part;
  820.     ngx_open_file_t  *file;

  822. #if (NGX_SUPPRESS_WARN)
  823.     ngx_str_null(&full);
  824. #endif

  826.     if (name->len) {
  827.         full = *name;

  829.         if (ngx_conf_full_name(cycle, &full, 0) != NGX_OK) {
  830.             return NULL;
  831.         }

  833.         part = &cycle->open_files.part;
  834.         file = part->elts;

  836.         for (i = 0; /* void */ ; i++) {

  838.             if (i >= part->nelts) {
  839.                 if (part->next == NULL) {
  840.                     break;
  841.                 }
  842.                 part = part->next;
  843.                 file = part->elts;
  844.                 i = 0;
  845.             }

  847.             if (full.len != file[i].name.len) {
  848.                 continue;
  849.             }

  851.             if (ngx_strcmp(full.data, file[i].name.data) == 0) {
  852.                 return &file[i];
  853.             }
  854.         }
  855.     }

  857.     file = ngx_list_push(&cycle->open_files);
  858.     if (file == NULL) {
  859.         return NULL;
  860.     }

  862.     if (name->len) {
  863.         file->fd = NGX_INVALID_FILE;
  864.         file->name = full;

  866.     } else {
  867.         file->fd = ngx_stderr;
  868.         file->name = *name;
  869.     }

  871.     file->flush = NULL;
  872.     file->data = NULL;

  874.     return file;
  875. }


  878. static void
  879. ‌ngx_conf_flush_files(ngx_cycle_t *cycle)
  880. {
  881.     ngx_uint_t        i;
  882.     ngx_list_part_t  *part;
  883.     ngx_open_file_t  *file;

  885.     ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0, "flush files");

  887.     part = &cycle->open_files.part;
  888.     file = part->elts;

  890.     for (i = 0; /* void */ ; i++) {

  892.         if (i >= part->nelts) {
  893.             if (part->next == NULL) {
  894.                 break;
  895.             }
  896.             part = part->next;
  897.             file = part->elts;
  898.             i = 0;
  899.         }

  901.         if (file[i].flush) {
  902.             file[i].flush(&file[i], cycle->log);
  903.         }
  904.     }
  905. }


  908. void ngx_cdecl
  909. ‌ngx_conf_log_error(ngx_uint_t level, ngx_conf_t *cf, ngx_err_t err,
  910.     const char *fmt, ...)
  911. {
  912.     u_char   errstr[NGX_MAX_CONF_ERRSTR], *p, *last;
  913.     va_list  args;

  915.     last = errstr + NGX_MAX_CONF_ERRSTR;

  917.     va_start(args, fmt);
  918.     p = ngx_vslprintf(errstr, last, fmt, args);
  919.     va_end(args);

  921.     if (err) {
  922.         p = ngx_log_errno(p, last, err);
  923.     }

  925.     if (cf->conf_file == NULL) {
  926.         ngx_log_error(level, cf->log, 0, "%*s", p - errstr, errstr);
  927.         return;
  928.     }

  930.     if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
  931.         ngx_log_error(level, cf->log, 0, "%*s in command line",
  932.                       p - errstr, errstr);
  933.         return;
  934.     }

  936.     ngx_log_error(level, cf->log, 0, "%*s in %s:%ui",
  937.                   p - errstr, errstr,
  938.                   cf->conf_file->file.name.data, cf->conf_file->line);
  939. }


  942. char *
  943. ‌ngx_conf_set_flag_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  944. {
  945.     char  *p = conf;

  947.     ngx_str_t        *value;
  948.     ngx_flag_t       *fp;
  949.     ngx_conf_post_t  *post;

  951.     fp = (ngx_flag_t *) (p + cmd->offset);

  953.     if (*fp != NGX_CONF_UNSET) {
  954.         return "is duplicate";
  955.     }

  957.     value = cf->args->elts;

  959.     if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
  960.         *fp = 1;

  962.     } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
  963.         *fp = 0;

  965.     } else {
  966.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  967.                      "invalid value \"%s\" in \"%s\" directive, "
  968.                      "it must be \"on\" or \"off\"",
  969.                      value[1].data, cmd->name.data);
  970.         return NGX_CONF_ERROR;
  971.     }

  973.     if (cmd->post) {
  974.         post = cmd->post;
  975.         return post->post_handler(cf, post, fp);
  976.     }

  978.     return NGX_CONF_OK;
  979. }


  982. char *
  983. ‌ngx_conf_set_str_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  984. {
  985.     char  *p = conf;

  987.     ngx_str_t        *field, *value;
  988.     ngx_conf_post_t  *post;

  990.     field = (ngx_str_t *) (p + cmd->offset);

  992.     if (field->data) {
  993.         return "is duplicate";
  994.     }

  996.     value = cf->args->elts;

  998.     *field = value[1];

  1000.     if (cmd->post) {
  1001.         post = cmd->post;
  1002.         return post->post_handler(cf, post, field);
  1003.     }

  1005.     return NGX_CONF_OK;
  1006. }


  1009. char *
  1010. ‌ngx_conf_set_str_array_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1011. {
  1012.     char  *p = conf;

  1014.     ngx_str_t         *value, *s;
  1015.     ngx_array_t      **a;
  1016.     ngx_conf_post_t   *post;

  1018.     a = (ngx_array_t **) (p + cmd->offset);

  1020.     if (*a == NGX_CONF_UNSET_PTR) {
  1021.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
  1022.         if (*a == NULL) {
  1023.             return NGX_CONF_ERROR;
  1024.         }
  1025.     }

  1027.     s = ngx_array_push(*a);
  1028.     if (s == NULL) {
  1029.         return NGX_CONF_ERROR;
  1030.     }

  1032.     value = cf->args->elts;

  1034.     *s = value[1];

  1036.     if (cmd->post) {
  1037.         post = cmd->post;
  1038.         return post->post_handler(cf, post, s);
  1039.     }

  1041.     return NGX_CONF_OK;
  1042. }


  1045. char *
  1046. ‌ngx_conf_set_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1047. {
  1048.     char  *p = conf;

  1050.     ngx_str_t         *value;
  1051.     ngx_array_t      **a;
  1052.     ngx_keyval_t      *kv;
  1053.     ngx_conf_post_t   *post;

  1055.     a = (ngx_array_t **) (p + cmd->offset);

  1057.     if (*a == NULL) {
  1058.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
  1059.         if (*a == NULL) {
  1060.             return NGX_CONF_ERROR;
  1061.         }
  1062.     }

  1064.     kv = ngx_array_push(*a);
  1065.     if (kv == NULL) {
  1066.         return NGX_CONF_ERROR;
  1067.     }

  1069.     value = cf->args->elts;

  1071.     kv->key = value[1];
  1072.     kv->value = value[2];

  1074.     if (cmd->post) {
  1075.         post = cmd->post;
  1076.         return post->post_handler(cf, post, kv);
  1077.     }

  1079.     return NGX_CONF_OK;
  1080. }


  1083. char *
  1084. ‌ngx_conf_set_num_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1085. {
  1086.     char  *p = conf;

  1088.     ngx_int_t        *np;
  1089.     ngx_str_t        *value;
  1090.     ngx_conf_post_t  *post;


  1093.     np = (ngx_int_t *) (p + cmd->offset);

  1095.     if (*np != NGX_CONF_UNSET) {
  1096.         return "is duplicate";
  1097.     }

  1099.     value = cf->args->elts;
  1100.     *np = ngx_atoi(value[1].data, value[1].len);
  1101.     if (*np == NGX_ERROR) {
  1102.         return "invalid number";
  1103.     }

  1105.     if (cmd->post) {
  1106.         post = cmd->post;
  1107.         return post->post_handler(cf, post, np);
  1108.     }

  1110.     return NGX_CONF_OK;
  1111. }


  1114. char *
  1115. ‌ngx_conf_set_size_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1116. {
  1117.     char  *p = conf;

  1119.     size_t           *sp;
  1120.     ngx_str_t        *value;
  1121.     ngx_conf_post_t  *post;


  1124.     sp = (size_t *) (p + cmd->offset);
  1125.     if (*sp != NGX_CONF_UNSET_SIZE) {
  1126.         return "is duplicate";
  1127.     }

  1129.     value = cf->args->elts;

  1131.     *sp = ngx_parse_size(&value[1]);
  1132.     if (*sp == (size_t) NGX_ERROR) {
  1133.         return "invalid value";
  1134.     }

  1136.     if (cmd->post) {
  1137.         post = cmd->post;
  1138.         return post->post_handler(cf, post, sp);
  1139.     }

  1141.     return NGX_CONF_OK;
  1142. }


  1145. char *
  1146. ‌ngx_conf_set_off_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1147. {
  1148.     char  *p = conf;

  1150.     off_t            *op;
  1151.     ngx_str_t        *value;
  1152.     ngx_conf_post_t  *post;


  1155.     op = (off_t *) (p + cmd->offset);
  1156.     if (*op != NGX_CONF_UNSET) {
  1157.         return "is duplicate";
  1158.     }

  1160.     value = cf->args->elts;

  1162.     *op = ngx_parse_offset(&value[1]);
  1163.     if (*op == (off_t) NGX_ERROR) {
  1164.         return "invalid value";
  1165.     }

  1167.     if (cmd->post) {
  1168.         post = cmd->post;
  1169.         return post->post_handler(cf, post, op);
  1170.     }

  1172.     return NGX_CONF_OK;
  1173. }


  1176. char *
  1177. ‌ngx_conf_set_msec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1178. {
  1179.     char  *p = conf;

  1181.     ngx_msec_t       *msp;
  1182.     ngx_str_t        *value;
  1183.     ngx_conf_post_t  *post;


  1186.     msp = (ngx_msec_t *) (p + cmd->offset);
  1187.     if (*msp != NGX_CONF_UNSET_MSEC) {
  1188.         return "is duplicate";
  1189.     }

  1191.     value = cf->args->elts;

  1193.     *msp = ngx_parse_time(&value[1], 0);
  1194.     if (*msp == (ngx_msec_t) NGX_ERROR) {
  1195.         return "invalid value";
  1196.     }

  1198.     if (cmd->post) {
  1199.         post = cmd->post;
  1200.         return post->post_handler(cf, post, msp);
  1201.     }

  1203.     return NGX_CONF_OK;
  1204. }


  1207. char *
  1208. ‌ngx_conf_set_sec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1209. {
  1210.     char  *p = conf;

  1212.     time_t           *sp;
  1213.     ngx_str_t        *value;
  1214.     ngx_conf_post_t  *post;


  1217.     sp = (time_t *) (p + cmd->offset);
  1218.     if (*sp != NGX_CONF_UNSET) {
  1219.         return "is duplicate";
  1220.     }

  1222.     value = cf->args->elts;

  1224.     *sp = ngx_parse_time(&value[1], 1);
  1225.     if (*sp == (time_t) NGX_ERROR) {
  1226.         return "invalid value";
  1227.     }

  1229.     if (cmd->post) {
  1230.         post = cmd->post;
  1231.         return post->post_handler(cf, post, sp);
  1232.     }

  1234.     return NGX_CONF_OK;
  1235. }


  1238. char *
  1239. ‌ngx_conf_set_bufs_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1240. {
  1241.     char *p = conf;

  1243.     ngx_str_t   *value;
  1244.     ngx_bufs_t  *bufs;


  1247.     bufs = (ngx_bufs_t *) (p + cmd->offset);
  1248.     if (bufs->num) {
  1249.         return "is duplicate";
  1250.     }

  1252.     value = cf->args->elts;

  1254.     bufs->num = ngx_atoi(value[1].data, value[1].len);
  1255.     if (bufs->num == NGX_ERROR || bufs->num == 0) {
  1256.         return "invalid value";
  1257.     }

  1259.     bufs->size = ngx_parse_size(&value[2]);
  1260.     if (bufs->size == (size_t) NGX_ERROR || bufs->size == 0) {
  1261.         return "invalid value";
  1262.     }

  1264.     return NGX_CONF_OK;
  1265. }


  1268. char *
  1269. ‌ngx_conf_set_enum_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1270. {
  1271.     char  *p = conf;

  1273.     ngx_uint_t       *np, i;
  1274.     ngx_str_t        *value;
  1275.     ngx_conf_enum_t  *e;

  1277.     np = (ngx_uint_t *) (p + cmd->offset);

  1279.     if (*np != NGX_CONF_UNSET_UINT) {
  1280.         return "is duplicate";
  1281.     }

  1283.     value = cf->args->elts;
  1284.     e = cmd->post;

  1286.     for (i = 0; e[i].name.len != 0; i++) {
  1287.         if (e[i].name.len != value[1].len
  1288.             || ngx_strcasecmp(e[i].name.data, value[1].data) != 0)
  1289.         {
  1290.             continue;
  1291.         }

  1293.         *np = e[i].value;

  1295.         return NGX_CONF_OK;
  1296.     }

  1298.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1299.                        "invalid value \"%s\"", value[1].data);

  1301.     return NGX_CONF_ERROR;
  1302. }


  1305. char *
  1306. ‌ngx_conf_set_bitmask_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1307. {
  1308.     char  *p = conf;

  1310.     ngx_uint_t          *np, i, m;
  1311.     ngx_str_t           *value;
  1312.     ngx_conf_bitmask_t  *mask;


  1315.     np = (ngx_uint_t *) (p + cmd->offset);
  1316.     value = cf->args->elts;
  1317.     mask = cmd->post;

  1319.     for (i = 1; i < cf->args->nelts; i++) {
  1320.         for (m = 0; mask[m].name.len != 0; m++) {

  1322.             if (mask[m].name.len != value[i].len
  1323.                 || ngx_strcasecmp(mask[m].name.data, value[i].data) != 0)
  1324.             {
  1325.                 continue;
  1326.             }

  1328.             if (*np & mask[m].mask) {
  1329.                 ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1330.                                    "duplicate value \"%s\"", value[i].data);

  1332.             } else {
  1333.                 *np |= mask[m].mask;
  1334.             }

  1336.             break;
  1337.         }

  1339.         if (mask[m].name.len == 0) {
  1340.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1341.                                "invalid value \"%s\"", value[i].data);

  1343.             return NGX_CONF_ERROR;
  1344.         }
  1345.     }

  1347.     return NGX_CONF_OK;
  1348. }


  1351. #if 0

  1353. char *
  1354. ngx_conf_unsupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1355. {
  1356.     return "unsupported on this platform";
  1357. }

  1359. #endif


  1362. char *
  1363. ‌ngx_conf_deprecated(ngx_conf_t *cf, void *post, void *data)
  1364. {
  1365.     ngx_conf_deprecated_t  *d = post;

  1367.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1368.                        "the \"%s\" directive is deprecated, "
  1369.                        "use the \"%s\" directive instead",
  1370.                        d->old_name, d->new_name);

  1372.     return NGX_CONF_OK;
  1373. }


  1376. char *
  1377. ‌ngx_conf_check_num_bounds(ngx_conf_t *cf, void *post, void *data)
  1378. {
  1379.     ngx_conf_num_bounds_t  *bounds = post;
  1380.     ngx_int_t  *np = data;

  1382.     if (bounds->high == -1) {
  1383.         if (*np >= bounds->low) {
  1384.             return NGX_CONF_OK;
  1385.         }

  1387.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1388.                            "value must be equal to or greater than %i",
  1389.                            bounds->low);

  1391.         return NGX_CONF_ERROR;
  1392.     }

  1394.     if (*np >= bounds->low && *np <= bounds->high) {
  1395.         return NGX_CONF_OK;
  1396.     }

  1398.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1399.                        "value must be between %i and %i",
  1400.                        bounds->low, bounds->high);

  1402.     return NGX_CONF_ERROR;
  1403. }

One Level Up Top Level