One Level Up Top Level

src/http/modules/ngx_http_index_module.c - nginx-1.31.4 nginx/ @ 8d9666701

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>
  10. #include <ngx_http.h>


  13. ‌typedef struct {
  14.     ngx_str_t                name;
  15.     ngx_array_t             *lengths;
  16.     ngx_array_t             *values;
  17. ‌} ngx_http_index_t;


  20. ‌typedef struct {
  21.     ngx_array_t             *indices;    /* array of ngx_http_index_t */
  22.     size_t                   max_index_len;
  23. ‌} ngx_http_index_loc_conf_t;


  26. ‌#define NGX_HTTP_DEFAULT_INDEX   "index.html"


  29. static ngx_int_t ngx_http_index_test_dir(ngx_http_request_t *r,
  30.     ngx_http_core_loc_conf_t *clcf, u_char *path, u_char *last);
  31. static ngx_int_t ngx_http_index_error(ngx_http_request_t *r,
  32.     ngx_http_core_loc_conf_t *clcf, u_char *file, ngx_err_t err);

  34. static ngx_int_t ngx_http_index_init(ngx_conf_t *cf);
  35. static void *ngx_http_index_create_loc_conf(ngx_conf_t *cf);
  36. static char *ngx_http_index_merge_loc_conf(ngx_conf_t *cf,
  37.     void *parent, void *child);
  38. static char *ngx_http_index_set_index(ngx_conf_t *cf, ngx_command_t *cmd,
  39.     void *conf);


  42. ‌static ngx_command_t  ngx_http_index_commands[] = {

  44.     { ngx_string("index"),
  45.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  46.       ngx_http_index_set_index,
  47.       NGX_HTTP_LOC_CONF_OFFSET,
  48.       0,
  49.       NULL },

  51.       ngx_null_command
  52. };


  55. ‌static ngx_http_module_t  ngx_http_index_module_ctx = {
  56.     NULL,                                  /* preconfiguration */
  57.     ngx_http_index_init,                   /* postconfiguration */

  59.     NULL,                                  /* create main configuration */
  60.     NULL,                                  /* init main configuration */

  62.     NULL,                                  /* create server configuration */
  63.     NULL,                                  /* merge server configuration */

  65.     ngx_http_index_create_loc_conf,        /* create location configuration */
  66.     ngx_http_index_merge_loc_conf          /* merge location configuration */
  67. };


  70. ‌ngx_module_t  ngx_http_index_module = {
  71.     NGX_MODULE_V1,
  72.     &ngx_http_index_module_ctx,            /* module context */
  73.     ngx_http_index_commands,               /* module directives */
  74.     NGX_HTTP_MODULE,                       /* module type */
  75.     NULL,                                  /* init master */
  76.     NULL,                                  /* init module */
  77.     NULL,                                  /* init process */
  78.     NULL,                                  /* init thread */
  79.     NULL,                                  /* exit thread */
  80.     NULL,                                  /* exit process */
  81.     NULL,                                  /* exit master */
  82.     NGX_MODULE_V1_PADDING
  83. };


  86. /*
  87. * Try to open/test the first index file before the test of directory
  88. * existence because valid requests should prevail over invalid ones.
  89. * If open()/stat() of a file will fail then stat() of a directory
  90. * should be faster because kernel may have already cached some data.
  91. * Besides, Win32 may return ERROR_PATH_NOT_FOUND (NGX_ENOTDIR) at once.
  92. * Unix has ENOTDIR error; however, it's less helpful than Win32's one:
  93. * it only indicates that path points to a regular file, not a directory.
  94. */

  96. static ngx_int_t
  97. ‌ngx_http_index_handler(ngx_http_request_t *r)
  98. {
  99.     u_char                       *p, *name;
  100.     size_t                        len, root, reserve, allocated;
  101.     ngx_int_t                     rc;
  102.     ngx_str_t                     path, uri;
  103.     ngx_uint_t                    i, dir_tested;
  104.     ngx_http_index_t             *index;
  105.     ngx_open_file_info_t          of;
  106.     ngx_http_script_code_pt       code;
  107.     ngx_http_script_engine_t      e;
  108.     ngx_http_core_loc_conf_t     *clcf;
  109.     ngx_http_index_loc_conf_t    *ilcf;
  110.     ngx_http_script_len_code_pt   lcode;

  112.     if (r->uri.data[r->uri.len - 1] != '/') {
  113.         return NGX_DECLINED;
  114.     }

  116.     if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD|NGX_HTTP_POST))) {
  117.         return NGX_DECLINED;
  118.     }

  120.     ilcf = ngx_http_get_module_loc_conf(r, ngx_http_index_module);
  121.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  123.     allocated = 0;
  124.     root = 0;
  125.     dir_tested = 0;
  126.     name = NULL;
  127.     /* suppress MSVC warning */
  128.     path.data = NULL;
  129.     e.status = 0;

  131.     index = ilcf->indices->elts;
  132.     for (i = 0; i < ilcf->indices->nelts; i++) {

  134.         if (index[i].lengths == NULL) {

  136.             if (index[i].name.data[0] == '/') {
  137.                 return ngx_http_internal_redirect(r, &index[i].name, &r->args);
  138.             }

  140.             reserve = ilcf->max_index_len;
  141.             len = index[i].name.len;

  143.         } else {
  144.             ngx_memzero(&e, sizeof(ngx_http_script_engine_t));

  146.             e.ip = index[i].lengths->elts;
  147.             e.request = r;
  148.             e.flushed = 1;

  150.             /* 1 is for terminating '\0' as in static names */
  151.             len = 1;

  153.             while (*(uintptr_t *) e.ip) {
  154.                 lcode = *(ngx_http_script_len_code_pt *) e.ip;
  155.                 len += lcode(&e);
  156.             }

  158.             /* 16 bytes are preallocation */

  160.             reserve = len + 16;
  161.         }

  163.         if (reserve > allocated) {

  165.             name = ngx_http_map_uri_to_path(r, &path, &root, reserve);
  166.             if (name == NULL) {
  167.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  168.             }

  170.             allocated = path.data + path.len - name;
  171.         }

  173.         if (index[i].values == NULL) {

  175.             /* index[i].name.len includes the terminating '\0' */

  177.             ngx_memcpy(name, index[i].name.data, index[i].name.len);

  179.             path.len = (name + index[i].name.len - 1) - path.data;

  181.         } else {
  182.             e.ip = index[i].values->elts;
  183.             e.pos = name;
  184.             e.end = name + allocated;

  186.             while (*(uintptr_t *) e.ip) {
  187.                 code = *(ngx_http_script_code_pt *) e.ip;
  188.                 code((ngx_http_script_engine_t *) &e);
  189.             }

  191.             if (e.status) {
  192.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  193.             }

  195.             if (ngx_http_script_check_length(&e, 1) != NGX_OK) {
  196.                 return NGX_ERROR;
  197.             }

  199.             if (*name == '/') {
  200.                 uri.len = e.pos - name;
  201.                 uri.data = name;
  202.                 return ngx_http_internal_redirect(r, &uri, &r->args);
  203.             }

  205.             len = e.pos - name + 1;
  206.             path.len = e.pos - path.data;

  208.             *e.pos = '\0';
  209.         }

  211.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  212.                        "open index \"%V\"", &path);

  214.         ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  216.         of.read_ahead = clcf->read_ahead;
  217.         of.directio = clcf->directio;
  218.         of.valid = clcf->open_file_cache_valid;
  219.         of.min_uses = clcf->open_file_cache_min_uses;
  220.         of.test_only = 1;
  221.         of.errors = clcf->open_file_cache_errors;
  222.         of.events = clcf->open_file_cache_events;

  224.         if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
  225.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  226.         }

  228.         if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
  229.             != NGX_OK)
  230.         {
  231.             if (of.err == 0) {
  232.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  233.             }

  235.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, of.err,
  236.                            "%s \"%s\" failed", of.failed, path.data);

  238. #if (NGX_HAVE_OPENAT)
  239.             if (of.err == NGX_EMLINK
  240.                 || of.err == NGX_ELOOP)
  241.             {
  242.                 return NGX_HTTP_FORBIDDEN;
  243.             }
  244. #endif

  246.             if (of.err == NGX_ENOTDIR
  247.                 || of.err == NGX_ENAMETOOLONG
  248.                 || of.err == NGX_EACCES)
  249.             {
  250.                 return ngx_http_index_error(r, clcf, path.data, of.err);
  251.             }

  253.             if (!dir_tested) {
  254.                 rc = ngx_http_index_test_dir(r, clcf, path.data, name - 1);

  256.                 if (rc != NGX_OK) {
  257.                     return rc;
  258.                 }

  260.                 dir_tested = 1;
  261.             }

  263.             if (of.err == NGX_ENOENT) {
  264.                 continue;
  265.             }

  267.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  268.                           "%s \"%s\" failed", of.failed, path.data);

  270.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  271.         }

  273.         uri.len = r->uri.len + len - 1;

  275.         if (!clcf->alias) {
  276.             uri.data = path.data + root;

  278.         } else {
  279.             uri.data = ngx_pnalloc(r->pool, uri.len);
  280.             if (uri.data == NULL) {
  281.                 return NGX_HTTP_INTERNAL_SERVER_ERROR;
  282.             }

  284.             p = ngx_copy(uri.data, r->uri.data, r->uri.len);
  285.             ngx_memcpy(p, name, len - 1);
  286.         }

  288.         return ngx_http_internal_redirect(r, &uri, &r->args);
  289.     }

  291.     return NGX_DECLINED;
  292. }


  295. static ngx_int_t
  296. ‌ngx_http_index_test_dir(ngx_http_request_t *r, ngx_http_core_loc_conf_t *clcf,
  297.     u_char *path, u_char *last)
  298. {
  299.     u_char                c;
  300.     ngx_str_t             dir;
  301.     ngx_open_file_info_t  of;

  303.     c = *last;
  304.     if (c != '/' || path == last) {
  305.         /* "alias" without trailing slash */
  306.         c = *(++last);
  307.     }
  308.     *last = '\0';

  310.     dir.len = last - path;
  311.     dir.data = path;

  313.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  314.                    "http index check dir: \"%V\"", &dir);

  316.     ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  318.     of.test_dir = 1;
  319.     of.test_only = 1;
  320.     of.valid = clcf->open_file_cache_valid;
  321.     of.errors = clcf->open_file_cache_errors;

  323.     if (ngx_http_set_disable_symlinks(r, clcf, &dir, &of) != NGX_OK) {
  324.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  325.     }

  327.     if (ngx_open_cached_file(clcf->open_file_cache, &dir, &of, r->pool)
  328.         != NGX_OK)
  329.     {
  330.         if (of.err) {

  332. #if (NGX_HAVE_OPENAT)
  333.             if (of.err == NGX_EMLINK
  334.                 || of.err == NGX_ELOOP)
  335.             {
  336.                 return NGX_HTTP_FORBIDDEN;
  337.             }
  338. #endif

  340.             if (of.err == NGX_ENOENT) {
  341.                 *last = c;
  342.                 return ngx_http_index_error(r, clcf, dir.data, NGX_ENOENT);
  343.             }

  345.             if (of.err == NGX_EACCES) {

  347.                 *last = c;

  349.                 /*
  350.                  * ngx_http_index_test_dir() is called after the first index
  351.                  * file testing has returned an error distinct from NGX_EACCES.
  352.                  * This means that directory searching is allowed.
  353.                  */

  355.                 return NGX_OK;
  356.             }

  358.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  359.                           "%s \"%s\" failed", of.failed, dir.data);
  360.         }

  362.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  363.     }

  365.     *last = c;

  367.     if (of.is_dir) {
  368.         return NGX_OK;
  369.     }

  371.     ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  372.                   "\"%s\" is not a directory", dir.data);

  374.     return NGX_HTTP_INTERNAL_SERVER_ERROR;
  375. }


  378. static ngx_int_t
  379. ‌ngx_http_index_error(ngx_http_request_t *r, ngx_http_core_loc_conf_t  *clcf,
  380.     u_char *file, ngx_err_t err)
  381. {
  382.     if (err == NGX_EACCES) {
  383.         ngx_log_error(NGX_LOG_ERR, r->connection->log, err,
  384.                       "\"%s\" is forbidden", file);

  386.         return NGX_HTTP_FORBIDDEN;
  387.     }

  389.     if (clcf->log_not_found) {
  390.         ngx_log_error(NGX_LOG_ERR, r->connection->log, err,
  391.                       "\"%s\" is not found", file);
  392.     }

  394.     return NGX_HTTP_NOT_FOUND;
  395. }


  398. static void *
  399. ‌ngx_http_index_create_loc_conf(ngx_conf_t *cf)
  400. {
  401.     ngx_http_index_loc_conf_t  *conf;

  403.     conf = ngx_palloc(cf->pool, sizeof(ngx_http_index_loc_conf_t));
  404.     if (conf == NULL) {
  405.         return NULL;
  406.     }

  408.     conf->indices = NULL;
  409.     conf->max_index_len = 0;

  411.     return conf;
  412. }


  415. static char *
  416. ‌ngx_http_index_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  417. {
  418.     ngx_http_index_loc_conf_t  *prev = parent;
  419.     ngx_http_index_loc_conf_t  *conf = child;

  421.     ngx_http_index_t  *index;

  423.     if (conf->indices == NULL) {
  424.         conf->indices = prev->indices;
  425.         conf->max_index_len = prev->max_index_len;
  426.     }

  428.     if (conf->indices == NULL) {
  429.         conf->indices = ngx_array_create(cf->pool, 1, sizeof(ngx_http_index_t));
  430.         if (conf->indices == NULL) {
  431.             return NGX_CONF_ERROR;
  432.         }

  434.         index = ngx_array_push(conf->indices);
  435.         if (index == NULL) {
  436.             return NGX_CONF_ERROR;
  437.         }

  439.         index->name.len = sizeof(NGX_HTTP_DEFAULT_INDEX);
  440.         index->name.data = (u_char *) NGX_HTTP_DEFAULT_INDEX;
  441.         index->lengths = NULL;
  442.         index->values = NULL;

  444.         conf->max_index_len = sizeof(NGX_HTTP_DEFAULT_INDEX);

  446.         return NGX_CONF_OK;
  447.     }

  449.     return NGX_CONF_OK;
  450. }


  453. static ngx_int_t
  454. ‌ngx_http_index_init(ngx_conf_t *cf)
  455. {
  456.     ngx_http_handler_pt        *h;
  457.     ngx_http_core_main_conf_t  *cmcf;

  459.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  461.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
  462.     if (h == NULL) {
  463.         return NGX_ERROR;
  464.     }

  466.     *h = ngx_http_index_handler;

  468.     return NGX_OK;
  469. }


  472. /* TODO: warn about duplicate indices */

  474. static char *
  475. ‌ngx_http_index_set_index(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  476. {
  477.     ngx_http_index_loc_conf_t *ilcf = conf;

  479.     ngx_str_t                  *value;
  480.     ngx_uint_t                  i, n;
  481.     ngx_http_index_t           *index;
  482.     ngx_http_script_compile_t   sc;

  484.     if (ilcf->indices == NULL) {
  485.         ilcf->indices = ngx_array_create(cf->pool, 2, sizeof(ngx_http_index_t));
  486.         if (ilcf->indices == NULL) {
  487.             return NGX_CONF_ERROR;
  488.         }
  489.     }

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

  493.     for (i = 1; i < cf->args->nelts; i++) {

  495.         if (value[i].data[0] == '/' && i != cf->args->nelts - 1) {
  496.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  497.                                "only the last index in \"index\" directive "
  498.                                "should be absolute");
  499.         }

  501.         if (value[i].len == 0) {
  502.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  503.                                "index \"%V\" in \"index\" directive is invalid",
  504.                                &value[i]);
  505.             return NGX_CONF_ERROR;
  506.         }

  508.         index = ngx_array_push(ilcf->indices);
  509.         if (index == NULL) {
  510.             return NGX_CONF_ERROR;
  511.         }

  513.         index->name.len = value[i].len;
  514.         index->name.data = value[i].data;
  515.         index->lengths = NULL;
  516.         index->values = NULL;

  518.         n = ngx_http_script_variables_count(&value[i]);

  520.         if (n == 0) {
  521.             if (ilcf->max_index_len < index->name.len) {
  522.                 ilcf->max_index_len = index->name.len;
  523.             }

  525.             if (index->name.data[0] == '/') {
  526.                 continue;
  527.             }

  529.             /* include the terminating '\0' to the length to use ngx_memcpy() */
  530.             index->name.len++;

  532.             continue;
  533.         }

  535.         ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  537.         sc.cf = cf;
  538.         sc.source = &value[i];
  539.         sc.lengths = &index->lengths;
  540.         sc.values = &index->values;
  541.         sc.variables = n;
  542.         sc.complete_lengths = 1;
  543.         sc.complete_values = 1;

  545.         if (ngx_http_script_compile(&sc) != NGX_OK) {
  546.             return NGX_CONF_ERROR;
  547.         }
  548.     }

  550.     return NGX_CONF_OK;
  551. }

One Level Up Top Level