One Level Up Top Level

src/core/ngx_conf_file.c - nginx-1.31.7 nginx/ @ 939334eff

Global variables defined

Data types 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_add_dump(ngx_conf_t *cf, ngx_str_t *filename);
  14. static ngx_int_t ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last);
  15. static ngx_int_t ngx_conf_read_token(ngx_conf_t *cf);
  16. static void ngx_conf_flush_files(ngx_cycle_t *cycle);


  19. ‌static ngx_command_t  ngx_conf_commands[] = {

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

  28.       ngx_null_command
  29. };


  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. };


  48. /* The eight fixed arguments */

  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. };


  62. ‌ngx_conf_post_t  ngx_conf_size_nonzero_post = { ngx_conf_check_size_nonzero };


  65. char *
  66. ‌ngx_conf_param(ngx_conf_t *cf)
  67. {
  68.     char             *rv;
  69.     ngx_str_t        *param;
  70.     ngx_buf_t         b;
  71.     ngx_conf_file_t   conf_file;

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

  75.     if (param->len == 0) {
  76.         return NGX_CONF_OK;
  77.     }

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

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

  83.     b.start = param->data;
  84.     b.pos = param->data;
  85.     b.last = param->data + param->len;
  86.     b.end = b.last;
  87.     b.temporary = 1;

  89.     conf_file.file.fd = NGX_INVALID_FILE;
  90.     conf_file.file.name.data = NULL;
  91.     conf_file.line = 0;

  93.     cf->conf_file = &conf_file;
  94.     cf->conf_file->buffer = &b;

  96.     rv = ngx_conf_parse(cf, NULL);

  98.     cf->conf_file = NULL;

  100.     return rv;
  101. }


  104. static ngx_int_t
  105. ‌ngx_conf_add_dump(ngx_conf_t *cf, ngx_str_t *filename)
  106. {
  107.     off_t             size;
  108.     u_char           *p;
  109.     uint32_t          hash;
  110.     ngx_buf_t        *buf;
  111.     ngx_str_node_t   *sn;
  112.     ngx_conf_dump_t  *cd;

  114.     hash = ngx_crc32_long(filename->data, filename->len);

  116.     sn = ngx_str_rbtree_lookup(&cf->cycle->config_dump_rbtree, filename, hash);

  118.     if (sn) {
  119.         cf->conf_file->dump = NULL;
  120.         return NGX_OK;
  121.     }

  123.     p = ngx_pstrdup(cf->cycle->pool, filename);
  124.     if (p == NULL) {
  125.         return NGX_ERROR;
  126.     }

  128.     cd = ngx_array_push(&cf->cycle->config_dump);
  129.     if (cd == NULL) {
  130.         return NGX_ERROR;
  131.     }

  133.     size = ngx_file_size(&cf->conf_file->file.info);

  135.     buf = ngx_create_temp_buf(cf->cycle->pool, (size_t) size);
  136.     if (buf == NULL) {
  137.         return NGX_ERROR;
  138.     }

  140.     cd->name.data = p;
  141.     cd->name.len = filename->len;
  142.     cd->buffer = buf;

  144.     cf->conf_file->dump = buf;

  146.     sn = ngx_palloc(cf->temp_pool, sizeof(ngx_str_node_t));
  147.     if (sn == NULL) {
  148.         return NGX_ERROR;
  149.     }

  151.     sn->node.key = hash;
  152.     sn->str = cd->name;

  154.     ngx_rbtree_insert(&cf->cycle->config_dump_rbtree, &sn->node);

  156.     return NGX_OK;
  157. }


  160. char *
  161. ‌ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
  162. {
  163.     char             *rv;
  164.     ngx_fd_t          fd;
  165.     ngx_int_t         rc;
  166.     ngx_buf_t         buf;
  167.     ngx_conf_file_t  *prev, conf_file;
  168. ‌    enum {
  169.         parse_file = 0,
  170.         parse_block,
  171.         parse_param
  172.     } type;

  174. #if (NGX_SUPPRESS_WARN)
  175.     fd = NGX_INVALID_FILE;
  176.     prev = NULL;
  177. #endif

  179.     if (filename) {

  181.         /* open configuration file */

  183.         fd = ngx_open_file(filename->data, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);

  185.         if (fd == NGX_INVALID_FILE) {
  186.             ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  187.                                ngx_open_file_n " \"%s\" failed",
  188.                                filename->data);
  189.             return NGX_CONF_ERROR;
  190.         }

  192.         prev = cf->conf_file;

  194.         cf->conf_file = &conf_file;

  196.         if (ngx_fd_info(fd, &cf->conf_file->file.info) == NGX_FILE_ERROR) {
  197.             ngx_log_error(NGX_LOG_EMERG, cf->log, ngx_errno,
  198.                           ngx_fd_info_n " \"%s\" failed", filename->data);
  199.         }

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

  203.         buf.start = ngx_alloc(NGX_CONF_BUFFER, cf->log);
  204.         if (buf.start == NULL) {
  205.             goto failed;
  206.         }

  208.         buf.pos = buf.start;
  209.         buf.last = buf.start;
  210.         buf.end = buf.last + NGX_CONF_BUFFER;
  211.         buf.temporary = 1;

  213.         cf->conf_file->file.fd = fd;
  214.         cf->conf_file->file.name.len = filename->len;
  215.         cf->conf_file->file.name.data = filename->data;
  216.         cf->conf_file->file.offset = 0;
  217.         cf->conf_file->file.log = cf->log;
  218.         cf->conf_file->line = 1;

  220.         type = parse_file;

  222.         if (ngx_dump_config
  223. #if (NGX_CONTROL_API)
  224.             || ngx_control_api_enabled
  225. #endif
  226. #if (NGX_DEBUG)
  227.             || 1
  228. #endif
  229.            )
  230.         {
  231.             if (ngx_conf_add_dump(cf, filename) != NGX_OK) {
  232.                 goto failed;
  233.             }

  235.         } else {
  236.             cf->conf_file->dump = NULL;
  237.         }

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

  241.         type = parse_block;

  243.     } else {
  244.         type = parse_param;
  245.     }


  248.     for ( ;; ) {
  249.         rc = ngx_conf_read_token(cf);

  251.         /*
  252.          * ngx_conf_read_token() may return
  253.          *
  254.          *    NGX_ERROR             there is error
  255.          *    NGX_OK                the token terminated by ";" was found
  256.          *    NGX_CONF_BLOCK_START  the token terminated by "{" was found
  257.          *    NGX_CONF_BLOCK_DONE   the "}" was found
  258.          *    NGX_CONF_FILE_DONE    the configuration file is done
  259.          */

  261.         if (rc == NGX_ERROR) {
  262.             goto done;
  263.         }

  265.         if (rc == NGX_CONF_BLOCK_DONE) {

  267.             if (type != parse_block) {
  268.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unexpected \"}\"");
  269.                 goto failed;
  270.             }

  272.             goto done;
  273.         }

  275.         if (rc == NGX_CONF_FILE_DONE) {

  277.             if (type == parse_block) {
  278.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  279.                                    "unexpected end of file, expecting \"}\"");
  280.                 goto failed;
  281.             }

  283.             goto done;
  284.         }

  286.         if (rc == NGX_CONF_BLOCK_START) {

  288.             if (type == parse_param) {
  289.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  290.                                    "block directives are not supported "
  291.                                    "in -g option");
  292.                 goto failed;
  293.             }
  294.         }

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

  298.         if (cf->handler) {

  300.             /*
  301.              * the custom handler, i.e., that is used in the http's
  302.              * "types { ... }" directive
  303.              */

  305.             if (rc == NGX_CONF_BLOCK_START) {
  306.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unexpected \"{\"");
  307.                 goto failed;
  308.             }

  310.             rv = (*cf->handler)(cf, NULL, cf->handler_conf);
  311.             if (rv == NGX_CONF_OK) {
  312.                 continue;
  313.             }

  315.             if (rv == NGX_CONF_ERROR) {
  316.                 goto failed;
  317.             }

  319.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "%s", rv);

  321.             goto failed;
  322.         }


  325.         rc = ngx_conf_handler(cf, rc);

  327.         if (rc == NGX_ERROR) {
  328.             goto failed;
  329.         }
  330.     }

  332. failed:

  334.     rc = NGX_ERROR;

  336. done:

  338.     if (filename) {
  339.         if (cf->conf_file->buffer->start) {
  340.             ngx_free(cf->conf_file->buffer->start);
  341.         }

  343.         if (ngx_close_file(fd) == NGX_FILE_ERROR) {
  344.             ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno,
  345.                           ngx_close_file_n " %s failed",
  346.                           filename->data);
  347.             rc = NGX_ERROR;
  348.         }

  350.         cf->conf_file = prev;
  351.     }

  353.     if (rc == NGX_ERROR) {
  354.         return NGX_CONF_ERROR;
  355.     }

  357.     return NGX_CONF_OK;
  358. }


  361. static ngx_int_t
  362. ‌ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last)
  363. {
  364.     char           *rv;
  365.     void           *conf, **confp;
  366.     ngx_uint_t      i, found;
  367.     ngx_str_t      *name;
  368.     ngx_command_t  *cmd;

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

  372.     found = 0;

  374.     for (i = 0; cf->cycle->modules[i]; i++) {

  376.         cmd = cf->cycle->modules[i]->commands;
  377.         if (cmd == NULL) {
  378.             continue;
  379.         }

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

  383.             if (name->len != cmd->name.len) {
  384.                 continue;
  385.             }

  387.             if (ngx_strcmp(name->data, cmd->name.data) != 0) {
  388.                 continue;
  389.             }

  391.             found = 1;

  393.             if (cf->cycle->modules[i]->type != NGX_CONF_MODULE
  394.                 && cf->cycle->modules[i]->type != cf->module_type)
  395.             {
  396.                 continue;
  397.             }

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

  401.             if (!(cmd->type & cf->cmd_type)) {
  402.                 continue;
  403.             }

  405.             if (!(cmd->type & NGX_CONF_BLOCK) && last != NGX_OK) {
  406.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  407.                                   "directive \"%s\" is not terminated by \";\"",
  408.                                   name->data);
  409.                 return NGX_ERROR;
  410.             }

  412.             if ((cmd->type & NGX_CONF_BLOCK) && last != NGX_CONF_BLOCK_START) {
  413.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  414.                                    "directive \"%s\" has no opening \"{\"",
  415.                                    name->data);
  416.                 return NGX_ERROR;
  417.             }

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

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

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

  425.                     if (cf->args->nelts != 2) {
  426.                         goto invalid;
  427.                     }

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

  431.                     if (cf->args->nelts < 2) {
  432.                         goto invalid;
  433.                     }

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

  437.                     if (cf->args->nelts < 3) {
  438.                         goto invalid;
  439.                     }

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

  443.                     goto invalid;

  445.                 } else if (!(cmd->type & argument_number[cf->args->nelts - 1]))
  446.                 {
  447.                     goto invalid;
  448.                 }
  449.             }

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

  453.             conf = NULL;

  455.             if (cmd->type & NGX_DIRECT_CONF) {
  456.                 conf = ((void **) cf->ctx)[cf->cycle->modules[i]->index];

  458.             } else if (cmd->type & NGX_MAIN_CONF) {
  459.                 conf = &(((void **) cf->ctx)[cf->cycle->modules[i]->index]);

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

  464.                 if (confp) {
  465.                     conf = confp[cf->cycle->modules[i]->ctx_index];
  466.                 }
  467.             }

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

  471.             if (rv == NGX_CONF_OK) {
  472.                 return NGX_OK;
  473.             }

  475.             if (rv == NGX_CONF_ERROR) {
  476.                 return NGX_ERROR;
  477.             }

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

  482.             return NGX_ERROR;
  483.         }
  484.     }

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

  490.         return NGX_ERROR;
  491.     }

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

  496.     return NGX_ERROR;

  498. invalid:

  500.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  501.                        "invalid number of arguments in \"%s\" directive",
  502.                        name->data);

  504.     return NGX_ERROR;
  505. }


  508. static ngx_int_t
  509. ‌ngx_conf_read_token(ngx_conf_t *cf)
  510. {
  511.     u_char      *start, ch, *src, *dst;
  512.     off_t        file_size;
  513.     size_t       len;
  514.     ssize_t      n, size;
  515.     ngx_uint_t   found, need_space, last_space, sharp_comment, variable;
  516.     ngx_uint_t   quoted, s_quoted, d_quoted, start_line;
  517.     ngx_str_t   *word;
  518.     ngx_buf_t   *b, *dump;

  520.     found = 0;
  521.     need_space = 0;
  522.     last_space = 1;
  523.     sharp_comment = 0;
  524.     variable = 0;
  525.     quoted = 0;
  526.     s_quoted = 0;
  527.     d_quoted = 0;

  529.     cf->args->nelts = 0;
  530.     b = cf->conf_file->buffer;
  531.     dump = cf->conf_file->dump;
  532.     start = b->pos;
  533.     start_line = cf->conf_file->line;

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

  537.     for ( ;; ) {

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

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

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

  545.                     if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
  546.                         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  547.                                            "unexpected end of parameter, "
  548.                                            "expecting \";\"");
  549.                         return NGX_ERROR;
  550.                     }

  552.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  553.                                        "unexpected end of file, "
  554.                                        "expecting \";\" or \"}\"");
  555.                     return NGX_ERROR;
  556.                 }

  558.                 return NGX_CONF_FILE_DONE;
  559.             }

  561.             len = b->pos - start;

  563.             if (len == NGX_CONF_BUFFER) {
  564.                 cf->conf_file->line = start_line;

  566.                 if (d_quoted) {
  567.                     ch = '"';

  569.                 } else if (s_quoted) {
  570.                     ch = '\'';

  572.                 } else {
  573.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  574.                                        "too long parameter \"%*s...\" started",
  575.                                        (size_t) 10, start);
  576.                     return NGX_ERROR;
  577.                 }

  579.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  580.                                    "too long parameter, probably "
  581.                                    "missing terminating \"%c\" character", ch);
  582.                 return NGX_ERROR;
  583.             }

  585.             if (len) {
  586.                 ngx_memmove(b->start, start, len);
  587.             }

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

  591.             if (size > b->end - (b->start + len)) {
  592.                 size = b->end - (b->start + len);
  593.             }

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

  598.             if (n == NGX_ERROR) {
  599.                 return NGX_ERROR;
  600.             }

  602.             if (n != size) {
  603.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  604.                                    ngx_read_file_n " returned "
  605.                                    "only %z bytes instead of %z",
  606.                                    n, size);
  607.                 return NGX_ERROR;
  608.             }

  610.             b->pos = b->start + len;
  611.             b->last = b->pos + n;
  612.             start = b->start;

  614.             if (dump) {
  615.                 dump->last = ngx_cpymem(dump->last, b->pos, size);
  616.             }
  617.         }

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

  621.         if (ch == LF) {
  622.             cf->conf_file->line++;

  624.             if (sharp_comment) {
  625.                 sharp_comment = 0;
  626.             }
  627.         }

  629.         if (sharp_comment) {
  630.             continue;
  631.         }

  633.         if (quoted) {
  634.             quoted = 0;
  635.             continue;
  636.         }

  638.         if (need_space) {
  639.             if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
  640.                 last_space = 1;
  641.                 need_space = 0;
  642.                 continue;
  643.             }

  645.             if (ch == ';') {
  646.                 return NGX_OK;
  647.             }

  649.             if (ch == '{') {
  650.                 return NGX_CONF_BLOCK_START;
  651.             }

  653.             if (ch == ')') {
  654.                 last_space = 1;
  655.                 need_space = 0;

  657.             } else {
  658.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  659.                                    "unexpected \"%c\"", ch);
  660.                 return NGX_ERROR;
  661.             }
  662.         }

  664.         if (last_space) {

  666.             start = b->pos - 1;
  667.             start_line = cf->conf_file->line;

  669.             if (ch == ' ' || ch == '\t' || ch == CR || ch == LF) {
  670.                 continue;
  671.             }

  673.             switch (ch) {

  675.             case ';':
  676.             case '{':
  677.                 if (cf->args->nelts == 0) {
  678.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  679.                                        "unexpected \"%c\"", ch);
  680.                     return NGX_ERROR;
  681.                 }

  683.                 if (ch == '{') {
  684.                     return NGX_CONF_BLOCK_START;
  685.                 }

  687.                 return NGX_OK;

  689.             case '}':
  690.                 if (cf->args->nelts != 0) {
  691.                     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  692.                                        "unexpected \"}\"");
  693.                     return NGX_ERROR;
  694.                 }

  696.                 return NGX_CONF_BLOCK_DONE;

  698.             case '#':
  699.                 sharp_comment = 1;
  700.                 continue;

  702.             case '\\':
  703.                 quoted = 1;
  704.                 last_space = 0;
  705.                 continue;

  707.             case '"':
  708.                 start++;
  709.                 d_quoted = 1;
  710.                 last_space = 0;
  711.                 continue;

  713.             case '\'':
  714.                 start++;
  715.                 s_quoted = 1;
  716.                 last_space = 0;
  717.                 continue;

  719.             case '$':
  720.                 variable = 1;
  721.                 last_space = 0;
  722.                 continue;

  724.             default:
  725.                 last_space = 0;
  726.             }

  728.         } else {
  729.             if (ch == '{' && variable) {
  730.                 continue;
  731.             }

  733.             variable = 0;

  735.             if (ch == '\\') {
  736.                 quoted = 1;
  737.                 continue;
  738.             }

  740.             if (ch == '$') {
  741.                 variable = 1;
  742.                 continue;
  743.             }

  745.             if (d_quoted) {
  746.                 if (ch == '"') {
  747.                     d_quoted = 0;
  748.                     need_space = 1;
  749.                     found = 1;
  750.                 }

  752.             } else if (s_quoted) {
  753.                 if (ch == '\'') {
  754.                     s_quoted = 0;
  755.                     need_space = 1;
  756.                     found = 1;
  757.                 }

  759.             } else if (ch == ' ' || ch == '\t' || ch == CR || ch == LF
  760.                        || ch == ';' || ch == '{')
  761.             {
  762.                 last_space = 1;
  763.                 found = 1;
  764.             }

  766.             if (found) {
  767.                 word = ngx_array_push(cf->args);
  768.                 if (word == NULL) {
  769.                     return NGX_ERROR;
  770.                 }

  772.                 word->data = ngx_pnalloc(cf->pool, b->pos - 1 - start + 1);
  773.                 if (word->data == NULL) {
  774.                     return NGX_ERROR;
  775.                 }

  777.                 for (dst = word->data, src = start, len = 0;
  778.                      src < b->pos - 1;
  779.                      len++)
  780.                 {
  781.                     if (*src == '\\') {
  782.                         switch (src[1]) {
  783.                         case '"':
  784.                         case '\'':
  785.                         case '\\':
  786.                             src++;
  787.                             break;

  789.                         case 't':
  790.                             *dst++ = '\t';
  791.                             src += 2;
  792.                             continue;

  794.                         case 'r':
  795.                             *dst++ = '\r';
  796.                             src += 2;
  797.                             continue;

  799.                         case 'n':
  800.                             *dst++ = '\n';
  801.                             src += 2;
  802.                             continue;
  803.                         }

  805.                     }
  806.                     *dst++ = *src++;
  807.                 }
  808.                 *dst = '\0';
  809.                 word->len = len;

  811.                 if (ch == ';') {
  812.                     return NGX_OK;
  813.                 }

  815.                 if (ch == '{') {
  816.                     return NGX_CONF_BLOCK_START;
  817.                 }

  819.                 found = 0;
  820.             }
  821.         }
  822.     }
  823. }


  826. char *
  827. ‌ngx_conf_include(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  828. {
  829.     char        *rv;
  830.     ngx_int_t    n;
  831.     ngx_str_t   *value, file, name;
  832.     ngx_glob_t   gl;

  834.     value = cf->args->elts;
  835.     file = value[1];

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

  839.     if (ngx_conf_full_name(cf->cycle, &file, 1) != NGX_OK) {
  840.         return NGX_CONF_ERROR;
  841.     }

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

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

  847.         return ngx_conf_parse(cf, &file);
  848.     }

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

  852.     gl.pattern = file.data;
  853.     gl.log = cf->log;
  854.     gl.test = 1;

  856.     if (ngx_open_glob(&gl) != NGX_OK) {
  857.         ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
  858.                            ngx_open_glob_n " \"%s\" failed", file.data);
  859.         return NGX_CONF_ERROR;
  860.     }

  862.     rv = NGX_CONF_OK;

  864.     for ( ;; ) {
  865.         n = ngx_read_glob(&gl, &name);

  867.         if (n != NGX_OK) {
  868.             break;
  869.         }

  871.         file.len = name.len++;
  872.         file.data = ngx_pstrdup(cf->pool, &name);
  873.         if (file.data == NULL) {
  874.             return NGX_CONF_ERROR;
  875.         }

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

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

  881.         if (rv != NGX_CONF_OK) {
  882.             break;
  883.         }
  884.     }

  886.     ngx_close_glob(&gl);

  888.     return rv;
  889. }


  892. ngx_int_t
  893. ‌ngx_conf_full_name(ngx_cycle_t *cycle, ngx_str_t *name, ngx_uint_t conf_prefix)
  894. {
  895.     ngx_str_t  *prefix;

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

  899.     return ngx_get_full_name(cycle->pool, prefix, name);
  900. }


  903. ngx_open_file_t *
  904. ‌ngx_conf_open_file(ngx_cycle_t *cycle, ngx_str_t *name)
  905. {
  906.     ngx_str_t         full;
  907.     ngx_uint_t        i;
  908.     ngx_list_part_t  *part;
  909.     ngx_open_file_t  *file;

  911. #if (NGX_SUPPRESS_WARN)
  912.     ngx_str_null(&full);
  913. #endif

  915.     if (name->len) {
  916.         full = *name;

  918.         if (ngx_conf_full_name(cycle, &full, 0) != NGX_OK) {
  919.             return NULL;
  920.         }

  922.         part = &cycle->open_files.part;
  923.         file = part->elts;

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

  927.             if (i >= part->nelts) {
  928.                 if (part->next == NULL) {
  929.                     break;
  930.                 }
  931.                 part = part->next;
  932.                 file = part->elts;
  933.                 i = 0;
  934.             }

  936.             if (full.len != file[i].name.len) {
  937.                 continue;
  938.             }

  940.             if (ngx_strcmp(full.data, file[i].name.data) == 0) {
  941.                 return &file[i];
  942.             }
  943.         }
  944.     }

  946.     file = ngx_list_push(&cycle->open_files);
  947.     if (file == NULL) {
  948.         return NULL;
  949.     }

  951.     if (name->len) {
  952.         file->fd = NGX_INVALID_FILE;
  953.         file->name = full;

  955.     } else {
  956.         file->fd = ngx_stderr;
  957.         file->name = *name;
  958.     }

  960.     file->flush = NULL;
  961.     file->data = NULL;

  963.     return file;
  964. }


  967. static void
  968. ‌ngx_conf_flush_files(ngx_cycle_t *cycle)
  969. {
  970.     ngx_uint_t        i;
  971.     ngx_list_part_t  *part;
  972.     ngx_open_file_t  *file;

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

  976.     part = &cycle->open_files.part;
  977.     file = part->elts;

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

  981.         if (i >= part->nelts) {
  982.             if (part->next == NULL) {
  983.                 break;
  984.             }
  985.             part = part->next;
  986.             file = part->elts;
  987.             i = 0;
  988.         }

  990.         if (file[i].flush) {
  991.             file[i].flush(&file[i], cycle->log);
  992.         }
  993.     }
  994. }


  997. void ngx_cdecl
  998. ‌ngx_conf_log_error(ngx_uint_t level, ngx_conf_t *cf, ngx_err_t err,
  999.     const char *fmt, ...)
  1000. {
  1001.     u_char   errstr[NGX_MAX_CONF_ERRSTR], *p, *last;
  1002.     va_list  args;

  1004.     last = errstr + NGX_MAX_CONF_ERRSTR;

  1006.     va_start(args, fmt);
  1007.     p = ngx_vslprintf(errstr, last, fmt, args);
  1008.     va_end(args);

  1010.     if (err) {
  1011.         p = ngx_log_errno(p, last, err);
  1012.     }

  1014.     if (cf->conf_file == NULL) {
  1015.         ngx_log_error(level, cf->log, 0, "%*s", p - errstr, errstr);
  1016.         return;
  1017.     }

  1019.     if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
  1020.         ngx_log_error(level, cf->log, 0, "%*s in command line",
  1021.                       p - errstr, errstr);
  1022.         return;
  1023.     }

  1025.     ngx_log_error(level, cf->log, 0, "%*s in %s:%ui",
  1026.                   p - errstr, errstr,
  1027.                   cf->conf_file->file.name.data, cf->conf_file->line);
  1028. }


  1031. char *
  1032. ‌ngx_conf_set_flag_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1033. {
  1034.     char  *p = conf;

  1036.     ngx_str_t        *value;
  1037.     ngx_flag_t       *fp;
  1038.     ngx_conf_post_t  *post;

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

  1042.     if (*fp != NGX_CONF_UNSET) {
  1043.         return "is duplicate";
  1044.     }

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

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

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

  1054.     } else {
  1055.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1056.                      "invalid value \"%s\" in \"%s\" directive, "
  1057.                      "it must be \"on\" or \"off\"",
  1058.                      value[1].data, cmd->name.data);
  1059.         return NGX_CONF_ERROR;
  1060.     }

  1062.     if (cmd->post) {
  1063.         post = cmd->post;
  1064.         return post->post_handler(cf, post, fp);
  1065.     }

  1067.     return NGX_CONF_OK;
  1068. }


  1071. char *
  1072. ‌ngx_conf_set_str_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1073. {
  1074.     char  *p = conf;

  1076.     ngx_str_t        *field, *value;
  1077.     ngx_conf_post_t  *post;

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

  1081.     if (field->data) {
  1082.         return "is duplicate";
  1083.     }

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

  1087.     *field = value[1];

  1089.     if (cmd->post) {
  1090.         post = cmd->post;
  1091.         return post->post_handler(cf, post, field);
  1092.     }

  1094.     return NGX_CONF_OK;
  1095. }


  1098. char *
  1099. ‌ngx_conf_set_str_array_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1100. {
  1101.     char  *p = conf;

  1103.     ngx_str_t         *value, *s;
  1104.     ngx_array_t      **a;
  1105.     ngx_conf_post_t   *post;

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

  1109.     if (*a == NGX_CONF_UNSET_PTR) {
  1110.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
  1111.         if (*a == NULL) {
  1112.             return NGX_CONF_ERROR;
  1113.         }
  1114.     }

  1116.     s = ngx_array_push(*a);
  1117.     if (s == NULL) {
  1118.         return NGX_CONF_ERROR;
  1119.     }

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

  1123.     *s = value[1];

  1125.     if (cmd->post) {
  1126.         post = cmd->post;
  1127.         return post->post_handler(cf, post, s);
  1128.     }

  1130.     return NGX_CONF_OK;
  1131. }


  1134. char *
  1135. ‌ngx_conf_set_keyval_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1136. {
  1137.     char  *p = conf;

  1139.     ngx_str_t         *value;
  1140.     ngx_array_t      **a;
  1141.     ngx_keyval_t      *kv;
  1142.     ngx_conf_post_t   *post;

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

  1146.     if (*a == NGX_CONF_UNSET_PTR || *a == NULL) {
  1147.         *a = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
  1148.         if (*a == NULL) {
  1149.             return NGX_CONF_ERROR;
  1150.         }
  1151.     }

  1153.     kv = ngx_array_push(*a);
  1154.     if (kv == NULL) {
  1155.         return NGX_CONF_ERROR;
  1156.     }

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

  1160.     kv->key = value[1];
  1161.     kv->value = value[2];

  1163.     if (cmd->post) {
  1164.         post = cmd->post;
  1165.         return post->post_handler(cf, post, kv);
  1166.     }

  1168.     return NGX_CONF_OK;
  1169. }


  1172. char *
  1173. ‌ngx_conf_set_num_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1174. {
  1175.     char  *p = conf;

  1177.     ngx_int_t        *np;
  1178.     ngx_str_t        *value;
  1179.     ngx_conf_post_t  *post;


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

  1184.     if (*np != NGX_CONF_UNSET) {
  1185.         return "is duplicate";
  1186.     }

  1188.     value = cf->args->elts;
  1189.     *np = ngx_atoi(value[1].data, value[1].len);
  1190.     if (*np == NGX_ERROR) {
  1191.         return "invalid number";
  1192.     }

  1194.     if (cmd->post) {
  1195.         post = cmd->post;
  1196.         return post->post_handler(cf, post, np);
  1197.     }

  1199.     return NGX_CONF_OK;
  1200. }


  1203. char *
  1204. ‌ngx_conf_set_size_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1205. {
  1206.     char  *p = conf;

  1208.     size_t           *sp;
  1209.     ngx_str_t        *value;
  1210.     ngx_conf_post_t  *post;


  1213.     sp = (size_t *) (p + cmd->offset);
  1214.     if (*sp != NGX_CONF_UNSET_SIZE) {
  1215.         return "is duplicate";
  1216.     }

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

  1220.     *sp = ngx_parse_size(&value[1]);
  1221.     if (*sp == (size_t) NGX_ERROR) {
  1222.         return "invalid value";
  1223.     }

  1225.     if (cmd->post) {
  1226.         post = cmd->post;
  1227.         return post->post_handler(cf, post, sp);
  1228.     }

  1230.     return NGX_CONF_OK;
  1231. }


  1234. char *
  1235. ‌ngx_conf_set_off_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1236. {
  1237.     char  *p = conf;

  1239.     off_t            *op;
  1240.     ngx_str_t        *value;
  1241.     ngx_conf_post_t  *post;


  1244.     op = (off_t *) (p + cmd->offset);
  1245.     if (*op != NGX_CONF_UNSET) {
  1246.         return "is duplicate";
  1247.     }

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

  1251.     *op = ngx_parse_offset(&value[1]);
  1252.     if (*op == (off_t) NGX_ERROR) {
  1253.         return "invalid value";
  1254.     }

  1256.     if (cmd->post) {
  1257.         post = cmd->post;
  1258.         return post->post_handler(cf, post, op);
  1259.     }

  1261.     return NGX_CONF_OK;
  1262. }


  1265. char *
  1266. ‌ngx_conf_set_msec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1267. {
  1268.     char  *p = conf;

  1270.     ngx_msec_t       *msp;
  1271.     ngx_str_t        *value;
  1272.     ngx_conf_post_t  *post;


  1275.     msp = (ngx_msec_t *) (p + cmd->offset);
  1276.     if (*msp != NGX_CONF_UNSET_MSEC) {
  1277.         return "is duplicate";
  1278.     }

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

  1282.     *msp = ngx_parse_time(&value[1], 0);
  1283.     if (*msp == (ngx_msec_t) NGX_ERROR) {
  1284.         return "invalid value";
  1285.     }

  1287.     if (cmd->post) {
  1288.         post = cmd->post;
  1289.         return post->post_handler(cf, post, msp);
  1290.     }

  1292.     return NGX_CONF_OK;
  1293. }


  1296. char *
  1297. ‌ngx_conf_set_sec_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1298. {
  1299.     char  *p = conf;

  1301.     time_t           *sp;
  1302.     ngx_str_t        *value;
  1303.     ngx_conf_post_t  *post;


  1306.     sp = (time_t *) (p + cmd->offset);
  1307.     if (*sp != NGX_CONF_UNSET) {
  1308.         return "is duplicate";
  1309.     }

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

  1313.     *sp = ngx_parse_time(&value[1], 1);
  1314.     if (*sp == (time_t) NGX_ERROR) {
  1315.         return "invalid value";
  1316.     }

  1318.     if (cmd->post) {
  1319.         post = cmd->post;
  1320.         return post->post_handler(cf, post, sp);
  1321.     }

  1323.     return NGX_CONF_OK;
  1324. }


  1327. char *
  1328. ‌ngx_conf_set_bufs_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1329. {
  1330.     char *p = conf;

  1332.     ngx_str_t   *value;
  1333.     ngx_bufs_t  *bufs;


  1336.     bufs = (ngx_bufs_t *) (p + cmd->offset);
  1337.     if (bufs->num) {
  1338.         return "is duplicate";
  1339.     }

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

  1343.     bufs->num = ngx_atoi(value[1].data, value[1].len);
  1344.     if (bufs->num == NGX_ERROR || bufs->num == 0) {
  1345.         return "invalid value";
  1346.     }

  1348.     bufs->size = ngx_parse_size(&value[2]);
  1349.     if (bufs->size == (size_t) NGX_ERROR || bufs->size == 0) {
  1350.         return "invalid value";
  1351.     }

  1353.     return NGX_CONF_OK;
  1354. }


  1357. char *
  1358. ‌ngx_conf_set_enum_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1359. {
  1360.     char  *p = conf;

  1362.     ngx_uint_t       *np, i;
  1363.     ngx_str_t        *value;
  1364.     ngx_conf_enum_t  *e;

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

  1368.     if (*np != NGX_CONF_UNSET_UINT) {
  1369.         return "is duplicate";
  1370.     }

  1372.     value = cf->args->elts;
  1373.     e = cmd->post;

  1375.     for (i = 0; e[i].name.len != 0; i++) {
  1376.         if (e[i].name.len != value[1].len
  1377.             || ngx_strcasecmp(e[i].name.data, value[1].data) != 0)
  1378.         {
  1379.             continue;
  1380.         }

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

  1384.         return NGX_CONF_OK;
  1385.     }

  1387.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1388.                        "invalid value \"%s\"", value[1].data);

  1390.     return NGX_CONF_ERROR;
  1391. }


  1394. char *
  1395. ‌ngx_conf_set_bitmask_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1396. {
  1397.     char  *p = conf;

  1399.     ngx_uint_t          *np, i, m;
  1400.     ngx_str_t           *value;
  1401.     ngx_conf_bitmask_t  *mask;


  1404.     np = (ngx_uint_t *) (p + cmd->offset);
  1405.     value = cf->args->elts;
  1406.     mask = cmd->post;

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

  1411.             if (mask[m].name.len != value[i].len
  1412.                 || ngx_strcasecmp(mask[m].name.data, value[i].data) != 0)
  1413.             {
  1414.                 continue;
  1415.             }

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

  1421.             } else {
  1422.                 *np |= mask[m].mask;
  1423.             }

  1425.             break;
  1426.         }

  1428.         if (mask[m].name.len == 0) {
  1429.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1430.                                "invalid value \"%s\"", value[i].data);

  1432.             return NGX_CONF_ERROR;
  1433.         }
  1434.     }

  1436.     return NGX_CONF_OK;
  1437. }


  1440. #if 0

  1442. char *
  1443. ngx_conf_unsupported(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1444. {
  1445.     return "unsupported on this platform";
  1446. }

  1448. #endif


  1451. char *
  1452. ‌ngx_conf_deprecated(ngx_conf_t *cf, void *post, void *data)
  1453. {
  1454.     ngx_conf_deprecated_t  *d = post;

  1456.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  1457.                        "the \"%s\" directive is deprecated, "
  1458.                        "use the \"%s\" directive instead",
  1459.                        d->old_name, d->new_name);

  1461.     return NGX_CONF_OK;
  1462. }


  1465. char *
  1466. ‌ngx_conf_check_num_bounds(ngx_conf_t *cf, void *post, void *data)
  1467. {
  1468.     ngx_conf_num_bounds_t  *bounds = post;
  1469.     ngx_int_t  *np = data;

  1471.     if (bounds->high == -1) {
  1472.         if (*np >= bounds->low) {
  1473.             return NGX_CONF_OK;
  1474.         }

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

  1480.         return NGX_CONF_ERROR;
  1481.     }

  1483.     if (*np >= bounds->low && *np <= bounds->high) {
  1484.         return NGX_CONF_OK;
  1485.     }

  1487.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1488.                        "value must be between %i and %i",
  1489.                        bounds->low, bounds->high);

  1491.     return NGX_CONF_ERROR;
  1492. }


  1495. char *
  1496. ‌ngx_conf_check_size_nonzero(ngx_conf_t *cf, void *post, void *data)
  1497. {
  1498.     size_t  *sp = data;

  1500.     if (*sp == 0) {
  1501.         return "value must be nonzero";
  1502.     }

  1504.     return NGX_CONF_OK;
  1505. }

One Level Up Top Level